The new age of the VB decompilation - VB Decompiler v9.0

After nearly six months of hard work, I'm happy to introduce VB Decompiler 9.0. You may say, why is it 9.0, not 8.5? There are a few reasons for that. The main one is I've completely ported the project from Visual Basic 6.0 to Delphi XE2. Basically, most of the new version is made from scratch. Though it was impossible to port many things as is, I've done my best to make all features work just like they did in the previous version, or even better.

My main achievement is backward compatibility. You can simply copy the new decompiler's EXE file into the folder containing the old version, and it will work fine! All old databases, plugins, knowledge base, and other things used in the previous versions are fully supported in the new version. VB Decompiler 9.0 supports them because I've created some complex classes for processing VB structures and variable-length VB strings, so that the new version can read and parse the databases initially optimized for Visual Basic. I've done a lot of work, and I've succeeded in ensuring backward compatibility!

Another important change is the full integration of the disassembler in the project. Now the emulator and the disassembler are part of the same class, which makes native code emulation much faster. As for the speed of execution, it has increased significantly compared to the previous versions of VB Decompiler. The reasons are as follows: I've greatly optimized the decompiler code and compiled the project into machine code, and now there is a special version for 64-bit Windows. As you can see, lots of things have been improved. Let's take a closer look at some optimizations.

VB Decompiler 9.0 uses a new TreeView control that, unlike the old one, doesn't slow down when a lot of items are added. You could easily see that when decompiling huge, complex projects containing lots of methods and functions. In the previous versions, going through the list of procedures in such files resulted in the control slowing down, and when you clicked on some item, the control could freeze for a few seconds. But now it's in the past. In the new version, everything works very fast!

I've greatly improved the functions for saving the result of decompilation in the database and loading it from there. I've also added several new fields and made a lot of fixes in the database's internal format. That rules out any garbling of the decompiled listing after loading it from the database even if the system language was changed, the original project file is missing, or some fields of metadata are empty.

I've greatly improved the emulation of native code. I've reworked the processing of FPU commands too, which you can see in the example below. Sample source code:

Const Test = "Test case2"

Private Sub Form_Load()
    Dim d As Double, e As Double
    a = &H100
    b = &H200
    c = Tan(Sin(a) * Cos(b))
    MsgBox c, 64, "Test case"
    d = 123456.123456
    e = Log(c / d + 7654.123)
    MsgBox e, 64, Test
End Sub

When using VB Decompiler 8.4, the result was as follows:

VB Decompiler 9.0 Pro produces a different result:

Now take a look at an example of calling some class properties. It's another accomplishment of VB Decompiler 9.0! The processing of calls to class properties and methods has finally been implemented and tested on a number of projects. So far, this improvement only applies to projects compiled into P-Code, but even that is a huge leap forward in decompiling Visual Basic programs.

The source code was as follows:

Private Sub Form_Load()
    Dim a As cAttribute
    Set a = New cAttribute
    a.ID = "Test 2"
    a.Description = "Test 1"
    MsgBox "12345"
    MsgBox a.Description, vbInformation, a.ID
End Sub

Here's the cAttribute class:

Option Explicit

Private m_ID As Byte
Private m_Description As String

Public Property Let Description(ByVal vData As String)
    m_Description = vData
End Property

Public Property Get Description() As String
    Description = m_Description
End Property

Public Property Let ID(ByVal vData As Byte)
    m_ID = vData
End Property

Public Property Get ID() As Byte
    ID = m_ID
End Property

Let's compare the decompiled code samples. Here's how it was in VB Decompiler 8.4:

And here's the same piece of code processed by VB Decompiler 9.0:

I've also added new functions for processing branches, cycles, and nested object properties. Now method prototypes and complex Let/Get/Set properties are generated correctly. The detection of GUIDs of external DLL and OCX files has been improved too. I cannot even tell you about every fix or improvement in this article! In short, a lot of things have been changed for better. One of the major news is the greatly improved functions for handling String References, which now work fine in projects of any size!

Despite the huge number of changes and improvements, the price of the product stays the same. As before, any software developer can afford buying VB Decompiler! And I'll be happy to see you among our customers! If you already have an active license for VB Decompiler, you can download and install the new version right now using the control panel on this website.

(C) Sergey Chubchenko, VB Decompiler's main developer

* Microsoft, Windows, and Visual Basic are registered trademarks of Microsoft Corporation.

Main     News     Products     Documentation     Articles     Plugins     Download     Order now     Contacts