Approach
A high-level look at how ProvenPort turns a source-less .NET binary into a modern build you can trust — and the evidence that comes with it.
ProvenPort starts from a simple, uncompromising idea: the original binary defines correct behavior. Not a specification, not the reconstructed source, not anyone's memory of what the code was supposed to do — the binary's actual, observable behavior is the single source of truth.
That reframes modernization from a creative task into a measurable one. The goal isn't to write code that looks right; it's to produce a modern build whose behavior is indistinguishable from the original — and to be able to show it.
We don't ask you to trust the modernized code. We measure it against the binary it replaces.
The starting point is deliberately minimal: a single compiled .NET Framework assembly — a .NET 4.x binary. No source code, no project files, no build scripts, no original author to consult. We've validated binaries spanning net 4.0 through net 4.8.
What comes back is not just a DLL that runs — it's readable, modern C# source that compiles on .NET 10, source your team owns and can maintain going forward, delivered together with the evidence that it behaves identically to the original binary.
Input
A source-less .NET 4.x binary — net 4.0 through net 4.8.
Output
Owned, buildable C# on .NET 10 — and proof it matches.
Getting a binary to run on modern .NET is the easy 80%. The dangerous 20% is making it behave exactly as before. Three forces work against a faithful port:
Turning a compiled binary back into buildable code is imperfect. The result can look correct yet rebuild differently — or fail to rebuild at all — without expert intervention.
Capabilities a library once carried itself were later absorbed into the platform. Reconciling that overlap, faithfully, is subtle work.
Moving to modern .NET quietly altered behavior in areas the compiler never warns about. A build that compiles cleanly can still produce different answers.
Each of these is a place where a naïve migration introduces silent regressions. ProvenPort is built to find them and resolve them with changes that preserve the original behavior by construction.
Proof, not assurance, is the product. The process is deliberately measured:
The original binary's behavior is captured over a broad range of conditions — what it returns, how it fails, what it changes.
The modernized build is exercised under the identical conditions, so the comparison is genuinely like-for-like.
Results are compared rigorously enough to catch differences that casual testing — or a human reviewer — would miss.
Any divergence is resolved with a verified, behavior-preserving change, then re-checked. The loop repeats until the two builds agree completely.
The outcome is a modern assembly accompanied by something a conversion tool can't offer: evidence that its behavior matches the original.
Establishing the golden reference means doing something most tools avoid: actually running the legacy binary — code whose source is lost and whose behavior nobody fully knows. Doing that on a normal machine would be reckless. ProvenPort executes every source-less assembly inside a hardened, disposable, network-isolated sandbox.
Each run lives in a throwaway, hypervisor-isolated container with no network access and a read-only view of the assembly — created for the run and destroyed at the end.
If the code deletes files, spawns processes, or reaches for the network, it does so harmlessly inside the sandbox. The host and your environment are never exposed.
Side effects aren't just blocked — they're recorded. What each build writes or changes is captured and compared, so equivalence covers behavior and effects, not just return values.
A useful by-product: because the original runs against the .NET Framework runtime inside the sandbox, modernizing a legacy binary never requires installing that legacy runtime on your own machines.
ProvenPort is AI-native, but the AI's role is deliberately bounded. The large, well-understood share of the work — the differences between framework generations that recur and have known, safe resolutions — is handled by a deterministic engine. Those changes are applied by construction; they don't need a model, and they don't get one.
AI is reserved for the exception: a genuinely novel divergence that no known pattern explains. There, the model is handed a tightly scoped problem — the exact input that differed, the two differing results, and the specific code responsible — and asked to propose a corrected implementation of just that piece.
No AI proposal is trusted on faith. Each one is recompiled and re-measured against the original binary, and kept only if it makes the behavior match. The AI accelerates the search for a fix; the equivalence proof is what accepts or rejects it.
Beyond our own measurements, ProvenPort earns trust the hardest possible way: it modernizes real open-source libraries from their legacy binaries, then runs each library's own test suite against the modernized result. A green run is independent, third-party evidence of equivalence.
Across one hundred libraries — spanning numerical computing, date and time, markdown, CSV, JSON and YAML serialization, localized text across dozens of languages, structured logging, resilience patterns, cron scheduling, templating, a full Lua interpreter, an x86 encoder-decoder, money and currency, an embedded database, HTML sanitization, cryptography, email and SSH clients, command-line parsing, state machines, and more — more than six hundred thousand of those tests pass, including one library with over four hundred thousand tests green. Along the way the process has surfaced genuine behavioral differences introduced by the modern runtime and restored the original behavior automatically: exactly the kind of silent change that makes unverified migration risky.
We're partnering with a small number of organizations that have source-less .NET Framework binaries on the critical path to modernization. If that's you, we'd like to talk.