VB Decompiler News

June 30, 2026
VB Decompiler v26.4 has been released
  • NEW: Visual form reconstruction for .NET assemblies. When the decompiler finds Windows Forms (WinForms) in a class (by analyzing its InitializeComponent method), it now renders a visual preview of the form, showing it close to how the end user would see it. A large set of standard controls is supported. At this time WPF is not supported, menu supported partially.

    Key points:
    • Fully self-contained: VB Decompiler does NOT use .NET or its classes to do this. Form parsing and rendering is entirely our own code and works even if the .NET Framework is not installed on the system.
    • Because this is a static emulation rather than real execution, some elements may be unsupported or rendered differently, but in about 90% of cases it lets you see the form as the user sees it.
    • Images are supported on controls, backgrounds, and elsewhere: icons, PNG, JPG, and other formats. All images placed on the forms can additionally be exported via the FRX Viewer plugin.
    • Interactive: click a control on the form to see the events that belong to it listed on the side panel. Double-clicking an event jumps straight to the decompiled code of that event handler.

    This is a must-have for analyzing .NET applications (C#, Visual Basic .NET) and is currently not available in any other tool in the world.
  • Added support for displaying menus in the visual form viewer for Visual Basic 5.0 and 6.0 P-Code and Native Code applications.
  • Added keyboard shortcuts for common actions in code and tree views. In the decompiler window: "N" to rename a variable, "X" to find references to a global variable, "D" to copy code to the disassembler, "F4" to trace to the address under the caret, and "Ctrl+Shift+Z" to undo a variable renaming. In the tree of classes and functions: "X" to find references to the selected function, "G" to jump to a section by its path, "Space" or "Insert" to mark/unmark an item, and "Ctrl+C" to copy the full tree path of the selected node. Shortcuts are context-aware and do not interfere with text input fields.
  • Added support for the back/forward side buttons on the mouse to navigate to the previous/next decompiled function in a history.
  • The "Trace to this address" command now detects the loc_ label at the start of the current line, so it works even when you click in the middle of the line rather than directly on the label.
  • Added support for the .NET FieldPtr table, which can be useful when analyzing obfuscated .NET applications.
  • Added support for .NET procedure arguments with indices greater than a 32-bit signed integer (only found in obfuscated code).
  • Fixed handling of huge obfuscated .NET procedures
  • FRXViewer plugin was not loading correctly if the previous opening was on a file without images. The source code for the fixed version of the plugin is also available on GitHub: DotFix Software FRX Viewer
  • Fixed decompilation of methods in P-Code with obfuscated object names, which caused the decompiler to hang.
  • The IL "callvirt" instruction could be decompiled incorrectly when the table entry number was 255.
April 13, 2026
VB Decompiler v26.3 has been released
  • A significant refactoring of the entire emulator code has been carried out
  • The key blocks and modules of the code optimizer have been completely rewritten, resulting in up to 8x faster decompilation for VB6 Native Code and up to 4x faster decompilation for .NET code
  • Optimized and accelerated the name mangler and demangler in .NET
  • Memory management has been significantly optimized; the decompiler now runs not only faster, but also consumes less RAM.
  • The code optimizer now tracks "goto" navigation links not only forward but also backward. Therefore, if previously parsed code was referenced from code below, but the optimizer filtered it as junk, the 'loc_' label is still preserved to prevent a jump to a non-existent marker. This is a purely visual feature, but it makes code analysis more convenient.
  • Unfortunately, the previous update contained a bug in parsing P-Code offsets, which prevented the decompiler from working on some files compiled in VB6 P-Code. This was quickly fixed.
April 05, 2026
VB Decompiler v26.2 has been released
  • A significant improvement in Native Code decompilation. Three types of detection for Variant variables on the stack during function calls are now supported:
    - heuristic, based on stack analysis
    - signature, based on a pre-prepared database of properties and methods of frequently used objects
    - on-the-fly type determination by parsing the interface of the object being called by its Interface ID.
    Parsing of called function parameters during early and late binding, as well as API calls, is now more accurate and correct.
  • Added snapshot-based state isolation for conditional branches: when the decompiler encounters an If/Else construct, it now saves a full snapshot of registers, CPU/FPU stack, and all variables at the branch point and restores it upon entering the Else block. This prevents state pollution between branches and significantly improves decompilation accuracy for code with complex conditional logic, particularly in user-defined class methods.
  • Rewritten analysis and filtering of temporary and unused variables in decompiled VB6 Native Code
  • Comprehensive SafeArray support for multidimensional array access in VB6 Native Code decompilation. Previously, only array creation and resizing operations (__vbaRedim and similar runtime APIs) were recognized. New version introduces full read and write reconstruction for array element access: the decompiler now parses the SAFEARRAY descriptor structure, reconstructs multidimensional index expressions from compiled offset arithmetic, correctly handles VarPtr calls on array elements, and suppresses compiler-generated bounds-check boilerplate from the output. Variables identified as SafeArray references are declared with explicit type annotations. This produces clean, readable subscript notation — such as var_20(1, 1, 1, 1) — in place of the raw pointer arithmetic and invalid expressions that previously appeared in its place.
  • The Variant type parser now support separating to internal subtypes: vbInteger, vbLong, vbByte, vbString, and vbObject. Parsing of TypeLibrary information and creation of the object database now takes these changes into pipeline. Previously, only the vbBoolean, vbSingle, vbDouble, vbCurrency, and vbDate subtypes were parsed separately within Variant. This change allows for more accurate processing of code sections where types were previously determined only heuristically.
  • The String Reference dialog supports over 32,000 strings. String searching and navigation are also supported.
  • Memory handling has been optimized when working with lists of strings.
  • A completely rewritten and revised translation of the Spanish help system. Special thanks to Leonardo Donaire for his work on the translation.
  • Changed signatures for the rtcGetSetting and rtcDeleteSetting API functions to support Variant type parameters.
  • The __vbaPrintObj API decompilation has been completely redesigned. Support for different print object types has been added when parsing parameters.
  • Decompilation of object creation has been completely reworked (emulating of __vbaNew2 msvbvmxx.dll API)
  • Emulation of the 'sar' shift assembly instruction used for signed division of numbers by 2, 4, etc. in VB6 Native
  • In the previous version, highlighting was added when selecting a local string variable all its occurrences in the code; now also added highlighting of global variables "global_XX"
  • The late-binding object recognition heuristic analyzer has been significantly expanded to include information about the mapping of IIDs to the following interfaces:
    - Basic COM OLE objects like ITypeLib, ICreateTypeInfo, ITypeInfo, etc
    - Inerfaces of Microsoft Word, Excel, Access, Outlook, PowerPoint
    - ADO (ActiveX Data Objects) and DAO (Data Access Objects)
    - MSXML, WinHTTP/WinInet, Scripting (FileSystemObject), Shell / WScript, Internet Explorer / WebBrowser
    - CDO / MAPI, ADSI (Active Directory), VBScript.RegExp
    Each interface also has a corresponding library GUID, and if it is registered in the registry, the TypeLib information required for the decompiler will be automatically pulled from it.
  • The code analyzer now pre-determines lines that contain conditional jumps and does not collapse this address if it contains temporary variables.
  • The code analyzer and optimizer have been significantly refactored and sped up. Post-processing improvements to raw code after decompilation are now significantly faster.
  • When maximizing the window to full screen, the AI Helper tab did not change size.
  • Attempting to navigate to a hidden compiler function from the String Reference dialog no longer causes in an error (.NET)
  • When reopening the trace window, in some cases lines of code from the previous trace remained in it.
  • The "Else" branch detection feature in the Native Code analyzer and optimizer did not insert an "End If" end block in some rare cases.
  • If a program compiled in P-Code was decompiled after decompiling another program compiled in Native Code, then 'this' was added to the basic properties of the Global object.
  • The 'Else' construct was not created if there was a conditional jump before it (VB6 Native Code)
March 08, 2026
VB Decompiler v26.1 has been released
  • New FRX Image Viewer plugin included: Browse and extract all embedded images, icons, and cursors from VB applications with thumbnail preview, automatic format detection (BMP, PNG, JPEG, GIF, ICO, CUR), and one-click export. Supports dark mode and multi-resolution icon parsing. Access via Plugins menu. The plugin's source code is available for free on GitHub:
    https://github.com/DotFixSoft/frxviewer
  • The local variable handling function in .NET procedures has been completely rewritten to work correctly on obfuscated procedures containing incorrect local variable declarations. This eliminates decompiler crashes when processing some heavily obfuscated .NET files.
  • Improved accessibility and keyboard navigation (NVDA screen reader friendly):
    - The Project Tree now supports selection/activation with the "Enter" key to open the selected form/module/procedure in the active viewer.
    - Added a new "Alt + 1" hotkey to quickly toggle focus between the Project Tree and the adjacent active view, allowing efficient UI navigation without repeatedly tabbing through controls.
    - Fixed natural Tab navigation in the Hex Editor: pressing Tab now correctly cycles through the Hex view and Text view, and then cleanly exits the control.
    - Improved screen reader context by strictly linking UI text labels to their corresponding input fields and comboboxes across the application.
  • New procedure analyzer and optimizer for C# code, decompiled from any .NET language (C#, VB .NET, etc). Optimizer now supports:
    LOOP RECONSTRUCTION
    - while loops: full detection and reconstruction from goto/label patterns
    - do-while loops: detection when condition variable is declared inside loop body
    - foreach loops: reconstructed from GetEnumerator/MoveNext/Dispose patterns (including try/finally wrapper)
    - Nested loops: while-in-while, while-in-foreach, while-in-if all correctly emitted inline
    - Loop condition inlining: single-step and two-step — condition folded into while header, intermediate variables eliminated
    IF/ELSE RECONSTRUCTION
    - Standard if/else chains from conditional goto patterns
    - Negated conditions normalized (op_Equality > ==, op_Inequality > !=, etc.)
    - Filter goto chains preserved correctly when body would be empty — semantics always maintained over aesthetics
    EXPRESSION OPTIMIZATION
    - Arithmetic and comparison operators inlined
    - Modulo operator reconstructed from div/mul/sub sequences
    - Boolean short-circuit patterns recognized
    - Method calls without arguments: parentheses normalized (.Trim > .Trim())
    - Interpolated string handlers collapsed into readable string concatenation expressions
    VARIABLE CLEANUP
    - Orphan return variables eliminated - simple temporaries only; field access, array access, method calls never deleted
    - Redundant condition variable copies removed from loop bodies
    STRUCTURAL CLEANUP
    - try/finally/catch blocks preserved and correctly indented
    - GetEnumerator/Current/MoveNext/Dispose foreach scaffolding removed
    - Label-only lines and dead reference comments stripped from output
    - goto elimination where target is next sequential instruction
  • Support decompilation to C# for "constrained.", "rem" and "rem.un" MS IL opcode in .NET
  • Variable highlighting now works the same for both "var_XX" and "str_XX" variables. When you click on a variable in the code, all places where it's used are highlighted, not only explicitly, but also as a structure or object (for example, clicking "str_1" will also highlight "str1.Value").
  • The position of controls on the AI Helper tab has been adjusted if the window size has not changed after loading the product.
  • In case of incorrect registry settings for AI Helper, LLM mode is selected by default.
February 10, 2026
VB Decompiler v26.0 has been released
  • AI Helper now supports not only Ollama LLM but also the OpenAI API, significantly expanding its capabilities. If your PC doesn't have a powerful enough graphics card, you can now connect to the ChatGPT or DeepSeek cloud model via the API to significantly improve the decompiled C# and VB6 code.
  • AI Helper configuration text fields now adapt to screen size. Additional fields can now be collapsed to free up useful space for the decompiled code.
  • The Plugin SDK has been completely updated. Sample plugins have been developed in Visual C++, Rust, Delphi, and Free Pascal, allowing you to quickly develop the plugin for VB Decompiler. Documentation for the Plugin SDK has also been written from scratch, making it easy to learn plugin development in any programming language that supports native DLL compilation:
    Example plugins have also been added to GitHub.
  • Checking for new program versions via a secure https protocol
  • In some cases, when the names of classes or modules of the decompiled program coincided with reserved names, a form was displayed instead of the code
VB Decompiler History