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.
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.
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 a growing set of libraries — spanning numerical computing, parsing, serialization, CSV processing, and localized text across dozens of languages — tens of thousands of those tests pass, including one library with over fifteen thousand tests green. In one case, the process surfaced a genuine behavioral difference 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.