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.

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.

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: 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.

Your VB6, WinForms, WebForms or .NET Framework app moves to .NET 8 one unit at a time, and keeps running the whole way across. Each unit arrives with proof that it does exactly what the old one did, and you read that proof before anything merges.

Book a Pilot See the Proof

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

Vinelift · The short version

Know the new code does what the old code did.

After a rewrite, nobody can prove the software still behaves the same. Old systems rarely have tests, the people who wrote them have moved on, and "it looks right" becomes the sign-off. So teams stay frozen on the old stack, or gamble on one big rewrite.

Vinelift starts with the tests. Before a line moves, it watches your running legacy system and records what it does: a golden master of today's behavior. Then it moves the app one unit at a time and certifies each new .NET 8 unit against that record. Any model can translate code; the proof that the translation changed nothing is what you're 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 person: an expected_change waiting for sign-off

Tests
Come FirstThe tests are recorded from what your app does today, before any code moves, so they can't inherit a wrong spec.

Unit
by UnitYour app keeps running behind a facade while units move across. Nothing merges until it's certified equivalent on its own.

Gates Never
LoosenA unit that can't be certified goes to a person. Only the 3× replay loop can set certified, and nothing approves itself.

Vinelift Harness

Your app on .NET 8.
And the proof.

Your application lands on supported .NET 8, moved in pieces so it keeps running the whole way across. With it comes the harness that makes it trustworthy: tests recorded from your running system, golden masters that are versioned and never edited, and seeded-mutation checks that must catch every planted false match before a release ships. A silent behavior change has nowhere to hide.

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

An audit you can read, unit by unit.

Every unit carries a verdict for each test case. Every gate decision lands in a log that can only be added to. Every intended change waits for your sign-off. The report is yours to read, line by line.

Get Your App's Report

Proof, not promises.

One rule governs the whole design: never trade verification for faster translation. A model that writes convincing C# is cheap and getting cheaper. Proving that the C# does exactly what the VB6 did, case by case on your own software, is the hard part, and it's what Vinelift is for. Behavior is the contract, so a unit that can't be certified goes to a person instead of through the gate.

Ingest → Characterize → Migrate → Certify (3× replay) → Seal to an append-only audit log. The same five phases run on a pilot and on the whole estate.

How it proves it

Observe the old. Replay the new. Compare.

Two loops do the work. The first is characterization: Vinelift drives the running legacy unit and records every input and output as a golden master, a captured record of what the software does today.

The second is certification: the migrated .NET 8 unit replays against that golden master three times and earns the certified flag only if every run matches. An intended difference is marked expected_change and waits for a person to confirm it. Only certified units reach the equivalence report, so the report can't call a unit equivalent that wasn't.

Strangler-fig migration

Legacy app → facade → units peeled to .NET 8

Calls route through a facade. One unit at a time is swapped for a certified .NET 8 version while the rest keeps running on the legacy code, so the system never goes down and the risk at any moment is one 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 it; a mismatch fails it, or, when the change was intended, holds it as an expected_change for a person to sign off.

Three ways to move a legacy app

One of the three ends with 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 test cases certified on the fixture-01 reference corridor: 274 of 279, across 26 units.

3×replays behind every certified flag. A unit matches three times or it doesn't certify.

100%of planted false matches caught. A silent behavior change is the failure the harness exists to stop.

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

Built to run inside your environment

Costs Capped per UnitEvery model call goes through one accounting layer with prompt caching and batching. Each unit has a token budget, and a unit that reaches three times its budget stops and goes to a person, so a migration's cost has a ceiling you can see.

Resumes Without ReworkEach pipeline saves its place in Postgres after every step. A run can stop and pick up again without redoing work, and re-running a migrated unit changes nothing, byte for byte.

Your Code Stays SandboxedYour code and recordings run in a sandbox with least-privilege mounts. Injected instructions are stripped before anything reaches a prompt, and no secrets sit in an agent's context. The runner adds no dependency without review.

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

A pilot takes one slice of your application, a corridor of related units, all the way across, so you can read the equivalence report before the rest of the estate moves.

Point It at Your App

Vinelift reads the legacy code and maps it into units and the dependencies between them. Nothing changes yet.

Record the Behavior

It records the running system and turns what it sees into tests of today's behavior.

Migrate and Certify

Units move to .NET 8 one at a time, and each is certified by 3× replay before it merges.

Read the Report

You get the equivalence report and the audit log: what's certified, what's flagged, and each intended change waiting for your sign-off.

Book a Pilot

A pilot stays small so you can check every verdict yourself, down to the diff behind it. Scope, price and timeline are set for each engagement.

Straight answers

Questions worth asking first.

What exactly can Vinelift migrate?

VB6, WinForms, WebForms and .NET Framework applications, to .NET 8. It moves them one unit at a time with the strangler-fig pattern, so a large system never depends on one big rewrite.

What does "behavioral equivalence" mean here?

It means the new unit gives the same outputs as the old one for every recorded case. Before migrating, Vinelift records the running legacy system and turns its behavior into tests, a golden master of what the software does today. The migrated .NET 8 unit replays against it and is certified only when three replays match. Only certified units reach the equivalence report.

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

An LLM can rewrite the code, but it can't tell you whether the rewrite behaves the same. A general model produces plausible C# and often invents tests that assert what it thinks should happen. Vinelift treats translation as the easy step and puts its effort into recording real behavior and proving the new code matches it. On the reference corridor, the certification loop refused five model-invented test expectations that the recorded behavior didn't support.

What happens to changes I want to make?

They wait for you. Where the migrated behavior differs on purpose, Vinelift marks it expected_change and holds it until a person confirms it. A unit that can't be certified goes to a person too.

Is my source code and data safe?

They're treated as untrusted input from the moment they arrive. They run in a sandbox with least-privilege mounts, injected instructions are stripped before anything reaches a prompt, and no secrets sit in an agent's context. The runner ships into your environment, so it adds no dependency without review.

Do I need Windows to run this?

Not for continuous integration. Windows-specific capabilities (ODBC shims, ETW, UI walking, VB6 builds) sit behind portable adapters with Linux and CI backends, so CI never needs Windows. The Windows-native capture backends are designed and not yet built; today the Linux and CI backends do the recording.

What are the numbers on this page?

They come from Vinelift's reference migration corridor, the fixture-01 benchmark used to build and test the pipeline: 26 units, 274 of 279 characterization cases certified, and every planted false match caught. They show the harness on a known fixture and are not results from a customer engagement.

How do I start?

With a pilot on one corridor of your application, so you can read the equivalence report before you commit the whole estate. Scope, price and timeline are set for each engagement.

Prove it.

Send us one corridor of your legacy app. Vinelift moves it to .NET 8 and hands you the equivalence report, with every certified unit, every flagged unit and the diff behind each 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.