// VB6 · WinForms · WebForms · .NET Framework → .NET 8
Vinelift is a behavior-preserving legacy migration factory. It moves aging Windows apps to modern .NET 8 and proves, unit by unit, that behavior is identical to the system you run today. The equivalence harness is the product — translation is a commodity.
Figures on this page are from Vinelift's reference migration corridor (the fixture-01 benchmark), not a customer engagement.
legacy · vb6' modInvoice.bas Function NetTotal( _ q As Long, _ price As Currency) NetTotal = q * price If q >= 12 Then NetTotal = _ NetTotal * 0.9 End If End Function
migrated · .net 8// Invoice.cs decimal NetTotal( long q, decimal price) { var total = q * price; if (q >= 12) total *= 0.9m; return total; }
Every legacy migration carries the same unspoken risk: after the rewrite, nobody can actually prove the software still behaves the same. Old systems rarely have tests, the original authors are gone, and "it looks right" is the acceptance criterion. So teams either freeze on the old stack or gamble on a big-bang rewrite.
Vinelift inverts the order of operations. Before it migrates a single line, it observes the running legacy system and generates characterization tests from its real behavior — a golden master. It then migrates unit by unit with the strangler-fig pattern, and certifies each new .NET 8 unit against that golden master. Translation is a commodity a model can do; the equivalence proof is what you're actually buying.
Your application, moved off the legacy stack onto supported .NET 8 — migrated incrementally, so it keeps running the whole way across.
The characterization suite and golden masters that prove the migration — and keep proving it every time the code changes afterward.
The whole design follows one rule: never optimize translation at the expense of verification. A model that writes convincing C# is cheap and getting cheaper. A system that can prove the C# does exactly what the VB6 did — case by case, on the customer's own software — is the thing worth building.
The mechanism is two loops. First, characterization: Vinelift drives the running legacy unit and records its inputs and outputs as a golden master — the ground truth of what the software does today, captured rather than guessed.
Then, certification: the migrated .NET 8 unit is replayed against that same golden master three times. It earns the certified flag only if every run matches. A legitimate, intended difference is marked expected_change and held for a human — it is never auto-approved. Only certified units feed the equivalence report, so a false "equivalent" is structurally impossible.
Calls route through a facade. One unit at a time is replaced with a certified .NET 8 version while the rest of the app keeps running on the legacy code — so the system is never fully down and risk is bounded to a single unit.
The legacy run defines the golden master. The migrated unit runs against it three times; a match certifies, a mismatch either fails the unit or, if intended, is held as an expected_change for human sign-off. Gates are never loosened to force a pass.
| Hand rewrite | Generic LLM translation | Vinelift | |
|---|---|---|---|
| Tests come from | Written from a spec (if one exists) | Usually none, or model-invented | The running legacy system |
| Behavioral equivalence | Hoped for, spot-checked | ✗ not proven | ✓ certified per unit |
| Silent behavior change | Found in production | Found in production | Caught — false-equivalence detection at 100% |
| Intended changes | Manual, ad hoc | Indistinguishable from bugs | Marked expected_change, human-confirmed |
| Cutover risk | Big-bang, high | Big-bang, high | Strangler-fig, bounded to one unit |
| Audit trail | Commit history | Prompt logs, if kept | Append-only, per gate decision |
| What you're left with | New code, unproven | New code, unproven | New code + a harness that proves it |
The migration runner executes inside your infrastructure, on your untrusted source. The engineering assumes exactly that.
Every model call routes through one accounting layer with prompt caching and batching. Per-unit token budgets trip a circuit breaker at 3× and escalate — cost is bounded and logged, never open-ended.
Each pipeline is a state machine checkpointed in Postgres; every step is idempotent per unit. A run can stop and resume without redoing work, and re-running a migrated unit is a byte-identical no-op.
Customer code and recordings run sandboxed, on least-privilege mounts, injection-stripped before any prompt, with no secrets in agent context. The runner takes no new dependency without review.
Never weaken a gate to make a unit pass. If it can't be certified, it's flagged for a human — not waved through. The moment a migration can quietly change behavior, it stops being a migration and starts being a rewrite you can't trust.
A pilot takes a single slice of your legacy application — one corridor of related units — end to end, so you can read the equivalence report before scaling to the rest of the estate.
The sequence is the same five phases the factory runs on everything:
Vinelift ingests the legacy tree and maps it into units and dependencies. Nothing is changed yet.
It records the running system and generates characterization tests, certified against the real observed behavior.
Units move to .NET 8 with the strangler-fig pattern, each certified equivalent by 3× replay before it's merged.
You get a per-unit equivalence report and audit log — what's certified, what's flagged, and every intended change to sign off.
A pilot is scoped to a corridor precisely so the claim can be checked, not taken on faith: you see certified units, flagged units, and the exact diffs behind each verdict. Scope, pricing, and timeline are set per engagement.
VB6, WinForms, WebForms, and .NET Framework — to modern .NET 8. It works incrementally, unit by unit, so a large system is moved with the strangler-fig pattern rather than one big-bang rewrite.certified only when a 3× replay confirms the outputs match. Only certified units feed the equivalence report, so a false "equivalent" can't be produced.expected_change and holds it for explicit human confirmation. There is no auto-approval path, and gates are never weakened to make a unit pass — a unit that can't be certified is escalated to a person.fixture-01 benchmark used to develop and test the factory (26 units; 274 of 279 characterization cases certified; false-equivalence detection held at 100%). They demonstrate the harness on a known fixture, not results from a customer engagement.Migrate one corridor. Read the proof.
See Vinelift take a slice of your legacy app to .NET 8 and hand you a per-unit equivalence report — certified units, flagged units, and the diffs behind every verdict.
Book a pilot corridorBehavior-preserving legacy migration · figures shown are from the fixture-01 reference corridor, not a customer engagement.