The developer left
The one person who wrote it retired, moved on, or passed away — and the source went with them.
We decompile compiled Visual Basic programs back into editable source code — rebuilt as a real project you can open, fix and ship again. Our specialty is native-compiled VB6, the hardest case in the business. We also handle VB1 to VB6 Native/P‑Code 16‑bit/32‑bit, .NET, QuickBASIC 4.5 and twinBASIC.
No commitment. You tell us about the program, we tell you what's recoverable. Prefer to do it in-house? Software licenses from $299 →
The program still works — until it needs a change, a fix, or a migration. Then someone goes looking for the source code, and it isn't there.
The one person who wrote it retired, moved on, or passed away — and the source went with them.
A dead drive, a lost laptop, an overwritten folder. The only copy left is the EXE running in production.
The company that built your custom software shut down and never handed over the code you paid for.
You inherited a critical system in a merger or handover — binaries only, documentation optional.
Plenty of tools will show you raw machine code. We deliver a reconstructed Visual Basic project — forms, modules, classes and logic — ready to reopen in the IDE and put back under your control.
The .vbp plus every form, module, class, user control and
designer — restored as editable files, organized like a developer left them.
Your screens come back: controls, properties, positions and event handlers — not a screenshot, the actual editable forms.
Procedures lifted back into readable Basic — conditions, loops, calculations, file I/O, API calls and string handling intact.
Icons, bitmaps, cursors and images extracted from the binary and returned alongside the project.
What came back verbatim, what was reconstructed, and what the compiler discarded — so your team knows exactly where they stand.
Download our free VBScanner to confirm what your program was built with — or skip this and just ask us.
Request an evaluation — what the program does, roughly how big it is, and what you know about how it was built.
We analyze the binary and reply with what's recoverable, what isn't, a fixed quote and a timeline. No obligation.
We run the recovery, verify the project rebuilds, and deliver your source, resources and report — under NDA if you need one.
We published full recoveries of two real native-compiled VB6 programs that kept their original source — so you can compare the hand-written code against what our engine brought back, file by file.
It's powered by our in-house recovery engine: 330+ specialized analysis passes that lift raw x86 machine code back into structured Basic.
Explore the side-by-side recoveries What customers sayAnyone promising you a byte-perfect copy of the original source is selling something that doesn't exist. Here's the truth — it's still very good news.
stored in the compiled binary
cmdSave_Click, Form_Load…)the compiler discards these names — every tool faces this
var_18, typed by how they're usedglobal_00488020proc_47D1D0field_4var_18 to employeeName takes your team seconds once
they can read the code doing the work. Our engine is honest by design:
it recovers what's really there and never fakes
what isn't.
Those generated names are the one chore left after a recovery, so the Suite
now offers to do it for you. The AI naming pass reads the recovered code —
each procedure's body, every place it's called from, the API calls and string
literals inside it — and proposes a real name for every proc_,
arg_, var_, global_ and
field_ placeholder. You see each suggestion, with the model's
one-line reason for it, before a single line of your project changes.
Public Function proc_406E80(arg_8) As Long '406E80 Dim var_30 As Variant Dim var_40 As Variant Dim var_F018 As Currency On Error GoTo loc_00406F4C var_40 = FreeFile() Open arg_8 For Binary As #var_40 Do While EOF(var_40) = 0 Get #var_40, , var_30 var_F018 = var_F018 + Sgn(var_30) Loop Close proc_406E80 = CLng(var_F018) Exit Function loc_00406F4C: proc_406E80 = -1 End Function
Public Function FileCheckSum(FilePath) As Long '406E80 'was proc_406E80, arg_8 Dim byteValue As Variant 'was var_30 Dim fileNum As Variant 'was var_40 Dim checkSum As Currency 'was var_F018 On Error GoTo loc_00406F4C fileNum = FreeFile() Open FilePath For Binary As #fileNum Do While EOF(fileNum) = 0 Get #fileNum, , byteValue checkSum = checkSum + Sgn(byteValue) Loop Close FileCheckSum = CLng(checkSum) Exit Function loc_00406F4C: FileCheckSum = -1 End Function
Real output, not a mock-up. pMasterMaker.exe, a native-compiled VB6 utility: one recovery run, then one naming run — 120 names applied across a form, a class and two modules. A few register-copy and jump-label lines were trimmed here to fit the column. The logic is untouched; only the labels changed.
Point it at Anthropic's Claude API or at OpenAI with a paid API key you hold yourself. You're billed by them, at their rates, for the tokens you use. We don't resell tokens and we don't mark them up. The window shows a token and cost estimate before it sends anything, and a large program can go through Claude's cheaper batch mode instead.
Anything that speaks OpenAI's API works, including a local Ollama or LM Studio server on your own machine. Choose that and the recovered code never leaves the computer — no key, no account, no per-token cost. It's the right answer for a binary that isn't allowed to go anywhere.
Every suggestion lands in a grid with the model's reason. Accept it, reject
it, or type your own name. Each accepted rename leaves the engine's original
on the declaration as a 'was proc_406E80 comment, so you can
always see what it really was, and one click puts every generated name back.
It's optional, and it's separate from the recovery itself. Every recovery works with no AI and no API key — the naming pass is a convenience layered on top. To use it you need either a paid API key from Anthropic or OpenAI, billed directly by them, or a local model you run yourself at no cost. It ships switched off and asks for your consent the first time, so nothing is ever sent anywhere you didn't choose.
And it can't quietly rewrite your program. Names the binary really
carried — event handlers, public procedures, control names, API declarations —
are never renamed. Suggestions are checked to be legal Basic identifiers that
collide with nothing else in the project, applied as whole identifiers only,
and kept in a separate names file rather than baked into the engine. Turn the
pass off and you get back the exact output you'd have had without it.
Site-license holders get the same pass on the command line with
/ai-rename for scripted, batch recoveries.
The VB Recovery Suite is the exact engine behind every recovery on this site — not a lite edition. License it when binaries can't leave your network or you have a shelf of programs to bring back. Or skip the software entirely and let us handle your recovery end to end.
The VB Recovery Suite · Windows 10 & 11
.vbp, forms, modules, classes, resourcesinstant download · need an invoice or PO?
The VB Recovery Suite · Windows 10 & 11
covers your whole team · need an invoice or PO?
We recover it, verify it, deliver it
ideal for one program · zero software to learn
Software licenses are issued to one person (single computer) or one organization (site license), include 12 months of updates and support, and are delivered as a download. Software sales are final. By purchasing you agree to our terms.
Yes. Our engine decompiles native-compiled and P-Code VB6 EXEs, DLLs and OCX controls back into a working VB6 project — forms with their controls, modules, classes and readable Basic — and does the same for every earlier Visual Basic. Use it yourself with a software license, or let us run the recovery for you. The VB6 decompiler page spells out what comes back, and the technology pages show real decompiled programs next to their original source.
We recover source for software you own or hold the rights to — your company's in-house programs, custom software you paid to have built, or products you've acquired. Before any work begins we ask you to confirm ownership in writing. We don't work on third-party software you don't have rights to.
The done-for-you service is quoted per project, because binaries vary enormously in size and complexity. The evaluation is free and no-obligation: we examine your file, tell you exactly what's recoverable, and give you a fixed price before you decide anything.
The software is priced flat: $299 for a single-computer license, or $1,499 for a site license covering every developer and machine in your organization. Both are one-time prices with 12 months of updates and support included. See pricing.
Yes. Your binaries and recovered source are handled privately, shared with no one, and deleted from our systems after delivery. We're happy to sign your NDA — or provide ours — before you send anything.
Our specialty is Visual Basic 6 compiled to native x86 code — the hardest case, and the one most decompilers can't handle. We also decompile VB6 and VB5 P-Code, VB5, VB4 (16-bit and 32-bit), VB3, VB2 and VB1, twinBASIC native EXEs, .NET assemblies (to C# or VB.NET) and QuickBASIC programs.
Each format has its own page describing exactly what comes back, and the formats overview compares them side by side. Not sure what you have? Download our free VBScanner or just send us the details.
The logic, strings, forms and API calls come back as written when we
decompile a program. Names the compiler discarded — local variables, globals, standard-module procedure
names — are reconstructed as readable placeholders like
var_18 or proc_47D1D0, and comments are never
stored in any compiled program. See
exactly what comes back above, or
compare real recoveries line for
line.
Not necessarily. UPX-packed binaries are handled routinely, and other packers are assessed case by case during the free evaluation. Worst case, we tell you it's not recoverable — before you've spent anything.
Yes — the same decompiler we use is available as a downloadable application for Windows 10 and 11: $299 for one computer, or $1,499 for an organization-wide site license covering unlimited machines and the headless command line. It's the right fit when binaries can't leave your network or you have many programs to recover. Buy online and download immediately, or request an invoice.
Small utilities can turn around in days; large multi-form business applications take longer. Your quote includes a committed timeline based on the actual binary, not a guess.
Send us the details today. Within a few business days you'll know exactly what's recoverable, what it costs, and how long it takes — for free.