VB Decompiler News

June 30, 2026
VB Decompiler v26.4 has been released
  • NEW: Visual form reconstruction for .NET assemblies. When the decompiler finds a Windows Form (WinForms) in a class by analyzing its InitializeComponent method, it now renders a visual preview that closely resembles the form seen by the end user. A wide range of standard controls is supported. WPF is not currently supported, and menu support is partial.

    Key points:
    • Fully self-contained: VB Decompiler does NOT use .NET or its classes for this feature. Form parsing and rendering are handled entirely by our own code and work even if the .NET Framework is not installed on the system.
    • Because this is static emulation rather than actual execution, some elements may be unsupported or rendered differently. However, in approximately 90% of cases, the viewer shows the form as the user would see 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 an essential feature for analyzing .NET applications written in C# or Visual Basic .NET, and, to the best of our knowledge, no other tool currently offers it.
  • 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 mouse's Back and Forward buttons, which navigate to the previous or next decompiled function in the navigation 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 the handling of extremely large obfuscated .NET procedures.
  • The FRX Viewer plugin did not load correctly if the previously opened file contained no images. The source code for the corrected 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
  • The entire emulator codebase has undergone significant refactoring.
  • Key code optimizer blocks and modules have been completely rewritten, resulting in up to 8x faster decompilation of VB6 Native Code and up to 4x faster decompilation of .NET code.
  • The .NET name mangler and demangler have been optimized and accelerated.
  • Memory management has been significantly optimized; the decompiler now runs faster and 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
  • Native Code decompilation has been significantly improved. Variant variables on the stack during function calls are now detected in three ways:
    - 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 parameters passed to functions through early binding, late binding, and API calls is now more accurate.
  • 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.
  • Analysis and filtering of temporary and unused variables in decompiled VB6 Native Code have been rewritten.
  • Comprehensive SafeArray support has been added for multidimensional array access in VB6 Native Code decompilation. Previously, only array creation and resizing operations (__vbaRedim and similar runtime APIs) were recognized. The new version fully reconstructs reads from and writes to array elements: the decompiler now parses the SAFEARRAY descriptor, reconstructs multidimensional index expressions from compiled offset arithmetic, correctly handles VarPtr calls on array elements, and suppresses compiler-generated bounds-checking boilerplate. 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) — instead of the raw pointer arithmetic and invalid expressions that previously appeared.
  • The Variant type parser can now distinguish the vbInteger, vbLong, vbByte, vbString, and vbObject subtypes. Type library parsing and object database generation now incorporate these distinctions. Previously, only vbBoolean, vbSingle, vbDouble, vbCurrency, and vbDate were parsed as separate Variant subtypes. This change enables more accurate processing of code sections in which types previously had to be inferred 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.
  • Object creation decompilation has been completely reworked by emulating the __vbaNew2 API from msvbvmXX.dll.
  • Emulation of the 'sar' shift assembly instruction used for signed division of numbers by 2, 4, etc. in VB6 Native
  • The previous version added highlighting for every occurrence of a selected local string variable. This release extends the feature to global variables named "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
    - Interfaces for Microsoft Word, Excel, Access, Outlook, and 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 identifies lines that contain conditional jumps in advance and does not collapse code at those addresses when temporary variables are present.
  • The code analyzer and optimizer have been significantly refactored and accelerated. Post-processing of raw decompiled code is now considerably 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 References dialog no longer causes 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
  • A new FRX Image Viewer plugin is included. It lets you browse and extract embedded images, icons, and cursors from VB applications, with thumbnail previews, automatic format detection (BMP, PNG, JPEG, GIF, ICO, and CUR), and one-click export. It also supports dark mode and multi-resolution icon parsing. Open it from the Plugins menu. The plugin's source code is available free of charge on GitHub:
    DotFix Software FRX Viewer source code.
  • 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.
  • A new procedure analyzer and optimizer has been added for C# code decompiled from any .NET language, including C# and Visual Basic .NET. The 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
  • Added C# decompilation support for the "constrained.", "rem", and "rem.un" MS IL opcodes (.NET).
  • Variable highlighting now works consistently for both "var_XX" and "str_XX" variables. Clicking a variable highlights every place where it is used, including access through a structure or object. For example, clicking "str_1" also highlights "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 both local Ollama models and the OpenAI API. If your PC does not have a sufficiently powerful graphics card, you can connect to cloud models such as ChatGPT or DeepSeek through an API to improve 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 in Visual C++, Rust, Delphi, and Free Pascal make it easier to develop plugins for VB Decompiler. The Plugin SDK documentation has also been rewritten from scratch and applies to any programming language that can compile native DLLs.
    Example VB Decompiler plugins on GitHub.
  • Update checks now use HTTPS.
  • In some cases, when a class or module name in the decompiled program matched a reserved name, VB Decompiler displayed a form instead of the code.
VB Decompiler History