An open, cross-platform IDE for Visual Basic 6 & VBA.
HexIDE reads and writes native .vbp/.frm/.bas/.cls files and layers on a modern,
LSP-backed editor — IntelliSense, diagnostics, code folding, rename, and formatting — over a
form designer and project manager. It runs on Windows, macOS, and Linux. No COM, no registry,
no Visual Studio required.
Status: Pre-alpha — early developer preview. HexIDE is a working cross-platform VB6 editor and form designer. It is not a compiler — the built-in interpreter runs only a subset of VB6, and producing a real
.execurrently shells out to an installed copy of the original VB6 (Windows only). Treat it as an early preview, not a finished product. Contributions and feedback are very welcome.Work on a copy. The file-format work has come a long way — 21 of VB6's own 22 template forms now survive a save byte-for-byte, and the one that does not is refused rather than damaged — but that corpus is Microsoft's templates, not your project. Anything hosting a third-party OCX is the known weak edge. See Opening real VB6 projects for exactly what it does and does not preserve.
Back it up first, or work on a copy, or at least commit before you open it.
That warning is measured, not boilerplate. The benchmark below is the 22 form and control files
Visual Basic 6 ships inside its own VB98\Template folder — Microsoft's files, written by VB6
itself. If HexIDE cannot re-emit those unchanged, it cannot re-emit yours.
| Against VB6's own 22 template forms | Today |
|---|---|
| Open, edit code, and run | all 22 |
| Survive open-then-save byte-for-byte | 21 |
| Open read-only — HexIDE refuses to save rather than damage them | 1 |
| Will save, but will not reproduce the original file | 0 |
The last three rows are two views of one thing, and that is the point: every VB6-authored form HexIDE is willing to save round-trips byte-for-byte, and the one it cannot reproduce it refuses outright. There is no longer a middle category — nothing saves lossily.
The holdout is Web Browser.frm, and it is the floor rather than a waypoint. Its six pictures sit on an
MSComctlLib.ImageList — an OCX, and hosting third-party controls is the project's largest declared gap.
It should stay refused until that lands, which makes 21 of 22 the ceiling for this corpus.
VB6's own project files (.vbp) round-trip byte-for-byte as well. So do standard and class modules
(.bas, .cls) — all three are covered by regression gates that fail the build if that stops being true.
Why forms are gated. A form HexIDE cannot reproduce opens read-only, with a banner saying so, and Save is refused. Refusing is recoverable; silently writing a file that only fails weeks later when you go back to VB6 is not. The reasoning is written up in docs/serialization-outcomes.md.
That count was 12, then six, and is now one. Menu trees started surviving a round-trip, which freed
VB6's six menu templates. Container nesting followed: a control inside a Frame or a PictureBox is
recorded on the model, written back nested, hosted by its container when the form runs, and drawn inside
it in the designer — which freed Options Dialog.frm and Tip of the Day.frm.
Then the companion-file model closed the rest. Button ListBox.frm and Mover ListBox.frm had been
saving lossily, dropping a control's picture reference while the .frx bytes survived on disk; the gate
learned to recognise that loss and refused them, and registering the properties that cite those blobs —
CommandButton.Picture and ListBox.DragIcon — made both reproducible instead. Treeview Listview Splitter.frm and Splash Screen.frm needed a VB.Image control class that did not exist. ODBC Log In.frm needed a .frx reader driven by the references in the form rather than a flat scan, because a
2-byte List/ItemData record is invisible to one.
The rule those six left under is the one the regression gate enforces: a form may only leave the read-only set by becoming reproducible, never by having its cause go unnoticed. A change that empties the set without OCX hosting behind it is a regression, not progress.
Companion binaries (.frx, .ctx, .pgx) are preserved, never regenerated. They hold icons,
pictures and list contents that exist nowhere else. When a form references a blob HexIDE does not
model, the save path leaves the companion file completely alone rather than rewriting it — an earlier
build regenerated them, which truncated one template's .frx from 790 bytes to 12 and deleted
another outright. Note the limit of that guarantee: the bytes are safe, but as above, the property
line in the .frm that points at them can still be dropped.
There is no autosave and no crash recovery. If HexIDE crashes, unsaved work is gone. VB6 was no better, but that is worth knowing in advance rather than discovering.
It is not a compiler. The built-in interpreter covers a subset of the language — enough to run
simple projects and demos, not enough to run a real application. Producing an actual .exe shells
out to an installed copy of VB6 and is therefore Windows-only.
None of this is permanent. It is where a from-scratch reimplementation of a 1998 file format honestly sits today, and the gap is tracked file-by-file in docs/serialization-fidelity-2026-08.md.
HexIDE should feel instantly familiar to a VB6 developer — the same default keybindings, menus, and toolbars — with the dead weight of 1998 removed or modernised and modern conveniences folded in gently, never at the cost of familiarity. See PHILOSOPHY.md for the full statement.
- 🎨 Visual form designer — drag-and-drop controls on a Win98-style canvas
- 📦 14 built-in controls — CommandButton, TextBox, Label, CheckBox, OptionButton, ComboBox, ListBox, Frame, PictureBox, Timer, Shape, Menu, HScrollBar, VScrollBar
- 💾 Native VB6 project format — reads
.vbp,.frm,.frx,.bas,.cls; writes.vbp,.frm,.bas,.cls(.frxcompanions are preserved as-is, not regenerated — see Opening real VB6 projects) - 🪟 MDI interface with dockable tool windows
- 💡 IntelliSense — keyword and declared-name completion as you type
- 📐 Code folding — Sub/Function/Property/If/For/Select and 11 other block types
- 🔍 Find & Replace — modeless, with regex, whole word, match case, and scope options
- 🖌️ Format code (Shift+Alt+F) — keyword casing + auto-indentation, with format-on-save
- ⌨️ Auto-close blocks — type
Sub Foo(), press Enter, andEnd Subappears - 🔤 Keyword case-correction —
public subbecomesPublic Subon Enter - ⚙️ Tools ▸ Options — persistent editor, grid, and environment settings
- 🚨 Live diagnostics — syntax errors as red squiggles with hover tooltips
⚠️ Option Explicitenforcement — undeclared variables flagged as warnings- 📝 Document symbols — two-combo procedure navigation (object + member)
- ✏️ Rename symbol (F2) — lexical rename across the current file
- 🎯 Go to Definition (F12) — jump to a declaration in the current file
- .NET 10 SDK or later
- No Java required — the ANTLR4 grammar compiles via MSBuild
git clone https://github.com/hexide-io/HexIDE.git
cd HexIDE
# Build & run the desktop app
cd IDE && dotnet build HexIDE.Desktop/
dotnet run --project HexIDE.Desktop/
# Run the test suites
cd IDE && dotnet test HexIDE.Runtime.Tests/ # VB6 interpreter
cd IDE && dotnet test HexIDE.Tests/ # IDE view-models
cd LspServer && dotnet test HexIDE.VbLspServer.Tests/ # LSP serverOpen HexIDE.slnx at the repo root — all projects, in two solution folders (IDE and
LspServer). Requires Visual Studio 2022 17.10+ for .slnx support.
HexIDE is a monorepo with a clean licence boundary:
HexIDE/
├── IDE/ # MIT — the IDE application
│ ├── HexIDE.Core/ # Framework-agnostic abstractions (no Avalonia)
│ ├── HexIDE/ # IDE shell, visual designer, code editor
│ ├── HexIDE.Runtime/ # VB6 interpreter & built-in controls
│ ├── HexIDE.Lsp/ # LSP client (StreamJsonRpc)
│ ├── HexIDE.Desktop/ # Desktop entry point
│ └── HexIDE.Standalone/ # Headless runner for published projects
│
├── LspServer/ # MIT — separate process (crash isolation)
│ └── HexIDE.VbLspServer/ # LSP server (proleap grammar + EmmyLua shell)
│
└── HexIDE.slnx # Master solution
The language features sit behind a standard LSP boundary — the IDE is only a client, and the server runs as its own subprocess for crash isolation. And the server is a replaceable backend, not a fixture — because the client is transport- and server-agnostic (it speaks only LSP JSON-RPC over a duplex byte stream, stdio on the desktop), a more capable language engine can take over language intelligence without any change to the IDE.
Under the hood, HexIDE.Core is a zero-dependency abstraction layer with no Avalonia
imports; Pure.DI provides source-generated, AOT-safe dependency injection; and theming is
driven by switchable theme packs (a Win98-style Classic theme ships today).
The server currently handles: initialize, didOpen/didChange/didClose, hover,
completion, signatureHelp, definition, documentHighlight, documentSymbol,
foldingRange, formatting, rename, and publishDiagnostics.
HexIDE is under active development. Near-term work is client-side editor polish: richer hover and completion (docs + icons), inline rename, signature help, more themes, and editor context menus.
Cross-file semantic analysis, project-wide navigation, and rename remain future work and need a dedicated language backend. The native interpreter debugger is available now, with breakpoints, stepping, Break, Immediate, Locals, Watches, and Call Stack.
Development happens in the open — see the issue tracker and Discussions to follow along or weigh in.
HexIDE would not exist without:
| Project | Author(s) | Contribution | Licence |
|---|---|---|---|
| AvaloniaVisualBasic6 | Bartosz Korczyński (@BAndysc) | The original IDE — form designer, component model, interpreter, project serialisation. HexIDE is a direct fork. | MIT |
| proleap-vb6-parser / grammars-v4 | Ulrich Wolffgang | The VB6 ANTLR4 grammar powering both the interpreter and the LSP server | MIT |
| EmmyLua.LanguageServer.Framework | CppCXY (the EmmyLua project) | The JSON-RPC + LSP protocol shell the language server is built on | MIT |
| Avalonia UI | Avalonia team | The cross-platform .NET UI framework | MIT |
| AvaloniaEdit | Avalonia community | The code editor control (port of ICSharpCode.AvalonEdit) | MIT |
| Classic.Avalonia | Avalonia community | Win98/Classic theme for VB6-style chrome | MIT |
| Dock | Wiesław Šoltés | Dockable tool-window layout | MIT |
| Pure.DI | Nikolay Pianikov | Source-generated DI (AOT-safe) | MIT |
Much of HexIDE was built in pair-programming with Claude (Anthropic).
"Visual Basic", "VB", and "VBA" are trademarks of Microsoft Corporation. HexIDE is an independent, community-built project — not affiliated with, endorsed by, or sponsored by Microsoft — and uses these names only descriptively to indicate VB6 file-format and workflow compatibility. See THIRD-PARTY-NOTICES.md for bundled-component attributions.
HexIDE is MIT-licensed throughout — both the IDE/ and LspServer/ halves. See LICENSE
and THIRD-PARTY-NOTICES.md.
The language server runs as a separate subprocess for crash isolation and a replaceable backend — not for any licensing reason.
HexIDE is in early development and contributions are welcome — bug reports, feature ideas, or pull requests. See CONTRIBUTING.md to get started. If you still work in VB6 or VBA and want to help bring the classic IDE to modern platforms, please get in touch.