What can Vinelift migrate?

Legacy Windows-stack applications — Visual Basic 6, WinForms, WebForms, and .NET Framework — to modern .NET 8. It works unit by unit using a strangler-fig approach, so a large application is moved incrementally rather than in one risky rewrite.

How does Vinelift handle changes I actually want?

An intended change is never auto-approved. Where the migrated behavior legitimately differs from the legacy behavior, Vinelift marks it as an expected_change and holds it for explicit human confirmation. Gates are never weakened to make a unit pass; a unit that cannot be certified is flagged for a person, not waved through.

Migrate the code.
Prove it didn't change.

Q: What does 'behavioral equivalence' actually mean?

Before any code is migrated, Vinelift records the running legacy system's behavior and generates characterization tests from it — a golden master of what the software actually does today. The migrated .NET 8 unit is then run against that same golden master. A unit is only marked certified when a 3x-replay certification loop confirms its canonicalized outputs match exactly. Translation is the easy part; the equivalence proof is the product.

Q: Is my source code and data safe?

Customer code and recordings are treated as untrusted data. They run in a sandbox with least-privilege mounts, are injection-stripped before ever reaching a prompt, and no secrets are placed in agent context. The migration runner ships into your environment, so it takes no new dependencies without review.

Vinelift moves aging VB6, WinForms, WebForms, and .NET Framework 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.

Book a pilot corridor See how it proves it

Figures on this page are from Vinelift's reference migration corridor (the fixture-01 benchmark), not a customer engagement.

Vinelift · The short version

You can't safely rewrite what you can't prove.

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.

98.2% certified

Reference corridor fixture-01: 26 units migrated & verified · 274 of 279 characterization cases certified · 5 cases held for human sign-off.

certified — canonicalized outputs matched exactly held for a human — expected_change, never auto-approved

Tests first,
from the running appCharacterization tests are recorded from real legacy behavior before any code moves — not written from a spec that may be wrong.

Strangler-fig,
unit by unitA large app is migrated incrementally behind a facade. Nothing is merged that hasn't been certified equivalent in isolation.

Gates never
weakenA unit that can't be certified is flagged for a person. certified is set only by the 3× replay loop — there is no auto-approval path.

Vinelift Harness

Two artifacts.
One of them is the point.

You get your application on supported .NET 8, migrated incrementally so it keeps running the whole way across. And you get the thing that makes it trustworthy: a living equivalence harness — characterization tests generated from your running legacy system, immutable versioned golden masters, and seeded-mutation detection that holds false-equivalence at 100%. A silent behavior change can't slip through.

How the proof works

unit: modInvoice.NetTotal

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;
}

CERTIFIED EQUIVALENT 279 cases · 0 diffs · 3× replay

Vinelift Certification

Terrace by terrace, each one proven.

A migration you can audit: every unit carries a per-case equivalence verdict, every gate decision lands in an append-only log, and intended changes are held for your sign-off — never auto-approved. The report is something you read, not something you take on faith.

Read one for your own app

Proof, not promises.

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 your own software — is the thing worth building. Behavior is the contract: never weaken a gate to make a unit pass. If it can't be certified, it's flagged for a human — not waved through.

Ingest → Characterize → Migrate → Certify (3× replay) → Seal to an append-only audit log. The same five phases run on everything, pilot or estate.

How it actually proves it

Observe the old. Replay the new. Compare.

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.

Strangler-fig migration

Legacy app → facade → units peeled to .NET 8

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 — the system is never fully down and risk is bounded to a single unit.

The 3× certification loop

Golden master vs. migrated unit → certified / flagged

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.

Three ways to move a legacy app

The difference is the proof.

How Vinelift compares to the two common approaches. "LLM translation" = a general model asked to rewrite the code.
	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

98.2%of characterization cases certified on the fixture-01 reference corridor — 274 of 279 across 26 units.

3×replay loop behind every certified flag. Match three times or it doesn't certify — there is no other path.

100%of seeded false-equivalence mutations caught. A silent behavior change is the one failure the harness exists to make impossible.

Reference corridor figures (fixture-01 benchmark), demonstrating the harness on a known fixture — not results from a customer engagement.

Built like it ships into your environment

Metered, tiered inferenceEvery 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.

Resumable pipelinesEach 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.

Untrusted by defaultCustomer 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.

Start with one corridor. See the proof before you commit.

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.

Point it at the app

Vinelift ingests the legacy tree and maps it into units and dependencies. Nothing is changed yet.

Characterize behavior

It records the running system and generates characterization tests, certified against the real observed behavior.

Migrate & certify

Units move to .NET 8 with the strangler-fig pattern, each certified equivalent by 3× replay before it's merged.

Read the report

You get a per-unit equivalence report and audit log — what's certified, what's flagged, and every intended change to sign off.

Scope a pilot corridor

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.

Straight answers

Questions worth asking.

What exactly can Vinelift migrate?

Legacy Windows-stack applications — 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.

What does "behavioral equivalence" actually mean here?

Before migrating, Vinelift records the running legacy system's real behavior and generates characterization tests from it — a golden master of what the software does today. The migrated .NET 8 unit is then replayed against that golden master. A unit is 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.

How is this different from just asking an LLM to rewrite my code?

A general model will happily produce plausible C# — but it can't tell you whether that C# behaves identically to the original, and it will often invent tests that assert what it thinks should happen. Vinelift treats translation as the commodity step and spends its effort on the part that's hard: capturing real behavior and proving the new code matches it. In the reference corridor, the certification loop refused to certify five model-invented test expectations that weren't present in the observed behavior — which is exactly the point.

What happens to changes I actually want to make?

An intended change is never silently accepted. Where migrated behavior legitimately differs, Vinelift marks it 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.

Is my source code and data safe?

Customer code and recordings are treated as untrusted input. They run in a sandbox with least-privilege mounts, are injection-stripped before reaching any prompt, and no secrets are placed in agent context. Because the runner ships into your environment, it takes no new dependencies without review.

Do I need Windows to run this?

Windows-specific capabilities (ODBC shims, ETW, UI walking, VB6 builds) sit behind portable adapter interfaces with Linux/CI backends, so continuous integration never requires Windows. The Windows-native capture backends are used where the source system genuinely needs them.

What are the numbers on this page?

They're from Vinelift's reference migration corridor — the 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.

How do I start?

With a pilot scoped to a single corridor of your application, so you can read the equivalence report before committing to the whole estate. Scope, pricing, and timeline are set per engagement.

Prove it.

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 corridor

Behavior-preserving legacy migration · figures shown are from the fixture-01 reference corridor, not a customer engagement.

Migrate the code.Prove it didn't change.