WoofWare.PawPrint 0.11.500

dotnet add package WoofWare.PawPrint --version 0.11.500
                    
NuGet\Install-Package WoofWare.PawPrint -Version 0.11.500
                    
This command is intended to be used within the Package Manager Console in Visual Studio, as it uses the NuGet module's version of Install-Package.
<PackageReference Include="WoofWare.PawPrint" Version="0.11.500" />
                    
For projects that support PackageReference, copy this XML node into the project file to reference the package.
<PackageVersion Include="WoofWare.PawPrint" Version="0.11.500" />
                    
Directory.Packages.props
<PackageReference Include="WoofWare.PawPrint" />
                    
Project file
For projects that support Central Package Management (CPM), copy this XML node into the solution Directory.Packages.props file to version the package.
paket add WoofWare.PawPrint --version 0.11.500
                    
#r "nuget: WoofWare.PawPrint, 0.11.500"
                    
#r directive can be used in F# Interactive and Polyglot Notebooks. Copy this into the interactive tool or source code of the script to reference the package.
#:package WoofWare.PawPrint@0.11.500
                    
#:package directive can be used in C# file-based apps starting in .NET 10 preview 4. Copy this into a .cs file before any lines of code to reference the package.
#addin nuget:?package=WoofWare.PawPrint&version=0.11.500
                    
Install as a Cake Addin
#tool nuget:?package=WoofWare.PawPrint&version=0.11.500
                    
Install as a Cake Tool

WoofWare.PawPrint

Slop status

Original architecture is by me, with only reference assistance from LLMs. Then in early 2026 I drove GPT-5.5 and Claude Opus 4.6/4.7 hard to get this to a usable state, resulting in release 0.1.1; I did review all the code during that time.

Since then, as I wanted to use this to debug some real life flaky tests, I drove GPT-5.6 Sol and Claude Opus 4.8/5 and Fable 5 much harder, and gradually stopped reading the code. As of August 2026, it would probably qualify as fully vibe-coded, although it is (astonishingly) a powerful and working tool which has actually debugged three real flaky tests in extremely nontrivial projects.

Description

This is an unfinished deterministic implementation of a .NET runtime (specifically .NET 10). You give it a DLL, and it executes the entry point therein on an emulated runtime which controls all sources of nondeterminism.

Current project status

Even incomplete as it is, PawPrint is currently capable of automatically detecting and reproducing a number of textbook race conditions, by running the input program with many different seeds for its source of randomness.

Nontrivial programs will probably fail loudly, unless you're lucky enough to be using only what I've already implemented.

The following work, at least in some minimal form:

  • Console.WriteLine
  • async void Main(string[] args) { ... }
  • Task.Run
  • Quite a lot of reflection
  • Many low-level synchronisation primitives like Monitor

The following are specifically not implemented:

  • GC and finalizers

Getting started

See the run-a-program.md doc for how to run a program, and fuzz-over-thread-scheduler.md for how to automatically detect concurrency-related bugs.

Building and testing offline

The default devshell (nix develop) restores NuGet packages from nuget.org as usual. On a machine or in a sandbox with no network, use the offline devshell instead, for example:

nix develop .#offline -c dotnet test WoofWare.PawPrint.Test/WoofWare.PawPrint.Test.fsproj

It resolves NuGet packages and SDK packs only from the Nix store, including self-contained publishing packs for linux-x64, linux-arm64 and osx-arm64. Nix may need network access to populate the store on first use; once its closure is present, restores, builds and tests need no access to nuget.org. NuGet's writable package cache is the ignored packages/ directory at the root of the checkout. Online vulnerability auditing is disabled in this shell.

Local tools use their own NuGet configuration. Bootstrap the manifest's tools from the offline shell's installable feed, then run the formatter as usual:

nix develop .#offline -c sh -c 'dotnet tool restore --configfile "$PAWPRINT_TOOL_NUGET_CONFIG"'
nix develop .#offline -c dotnet fantomas .

The offline shell knows only the packages pinned in nix/deps.json. After changing package references, regenerate the pins with network access:

nix build .#default.fetch-deps && ./result nix/deps.json

Re-enter nix develop .#offline to use the new closure. A package missing from the pins fails restore in that shell instead of falling back to nuget.org. nix flake check verifies that the whole solution and the local tools restore offline with empty package, tool and HTTP caches, that both tools start, and that CSharpExample publishes as a self-contained application for each supported RID.

Goals

  • Fully deterministic, ultimately to the point of supporting time-travel debugging and fuzzing over the order of thread execution. All sources of nondeterminism must be controllable by the PawPrint user somehow, such that emulating the same program twice from the same starting state always produces the same execution history.
  • Fully managed. For example, I reimplement a large number of methods which are defined by P/Invoke, so that my deterministic runtime does not have to emulate native code.
  • Fully in-memory except insofar as the program under test performs filesystem operations. (Filesystem operations are not yet supported, although the stderr/stdout file descriptors are.)
  • No monkey-patching stuff out for convenience. IL interpretation is faithful. We emulate a rather eccentric JIT (the BCL relies on the presence of a JIT!), but if it's not a JIT intrinsic and it's not native code, we execute its genuine implementation.

Non-goals

  • Performance. I expect this to be a very slow IL interpreter.
  • Fidelity to the optimisations performed by e.g. RyuJIT or .NET's GC. I am purely interpreting IL (and mocking out native calls). For example, it is likely that I will simply never deallocate memory (so e.g. finalisers are not run).
  • Support for any operating systems other than the ones on which I am running (currently macOS and Linux), and any fancy hardware features like SIMD.

Correctness

The project aims for correctness over availability, and will happily crash whenever it doesn't recognise some situation.

An advantage of a .NET runtime as a project is that it's unusually easy to test, because the CLR is a reference implementation. WoofWare.PawPrint has quite a lot of tests that "some C# code has the same observable result under PawPrint and the CLR", and a couple of F# tests too. (This makes me much happier about the rampant LLM usage than I would otherwise have been!)

Licence

MIT.

This project was produced with reference to the .NET runtime, which was used under the MIT licence. WoofWare.PawPrint may contain small amounts of that code.

Product Compatible and additional computed target framework versions.
.NET net8.0 is compatible.  net8.0-android was computed.  net8.0-browser was computed.  net8.0-ios was computed.  net8.0-maccatalyst was computed.  net8.0-macos was computed.  net8.0-tvos was computed.  net8.0-windows was computed.  net9.0 was computed.  net9.0-android was computed.  net9.0-browser was computed.  net9.0-ios was computed.  net9.0-maccatalyst was computed.  net9.0-macos was computed.  net9.0-tvos was computed.  net9.0-windows was computed.  net10.0 was computed.  net10.0-android was computed.  net10.0-browser was computed.  net10.0-ios was computed.  net10.0-maccatalyst was computed.  net10.0-macos was computed.  net10.0-tvos was computed.  net10.0-windows was computed. 
Compatible target framework(s)
Included target framework(s) (in package)
Learn more about Target Frameworks and .NET Standard.

NuGet packages

This package is not used by any NuGet packages.

GitHub repositories

This package is not used by any popular GitHub repositories.

Version Downloads Last Updated
0.11.500 86 11/17/2026
0.6.6 190 8/16/2026
0.6.5 124 8/15/2026
0.6.4 122 8/15/2026
0.6.3 129 8/15/2026
0.6.2 128 8/15/2026
0.6.1 133 8/15/2026
0.5.4 119 8/15/2026
0.5.3 116 8/15/2026
0.5.2 125 8/15/2026
0.5.1 114 8/15/2026
0.4.9 129 8/15/2026
0.4.8 118 8/15/2026
0.4.7 126 8/15/2026
0.4.6 119 8/15/2026
0.4.5 139 8/15/2026
0.4.4 127 8/15/2026
0.4.3 137 8/15/2026
0.4.2 126 8/15/2026
0.4.1 140 8/15/2026
Loading failed