# DE Decompiler 26.7: More Accurate Code Recovery for Native Applications > DE Decompiler 26.7 improves conditions, strings, properties and call reconstruction. Explore native-code analysis and VCL form recovery with screenshots. Canonical HTML: ## DE Decompiler 26.7: More Accurate Code Recovery for Native Applications November 2, 2026 DE Decompiler 26.7 is available. This release focuses on a central task in native-code analysis: reconstructing readable program logic while preserving the relationships between values, branches and calls. It improves the recovery of conditions, string results, inherited properties and function arguments, alongside library identification and analysis stability. DE Decompiler is a professional tool for reverse engineers, forensic investigators, malware analysts, security teams and developers examining Win32 and Win64 VCL applications written in Delphi or built with C++Builder. It connects recovered forms, units, classes and functions with Delphi-like Pascal code, native disassembly and file bytes. The following overview covers the key changes in 26.7 and the analysis workflow introduced in recent releases. ### Conditions, branches and function results A compiled procedure can select a value along several branches, save it and use it much later. Reconstructing that sequence requires distinguishing the saved value from subsequent calculations. Version 26.7 improves conditions that depend on values chosen across three or more branches and reduces unresolved intermediate values in the recovered code. The update also improves shared return paths, early returns and common error-handling blocks. Function results are retained through cleanup operations, and a value assigned in one branch is not substituted on a path where that assignment never occurred. Previously missing calls in Boolean conditions and nested branches are recovered more reliably. Call order matters when an expression changes program state. Improved handling of reused function results keeps a single call from becoming several calls in the listing, including within value selections and loop conditions. Delphi type tests and checked object casts are also represented as `is` and `as` expressions in more cases, retaining the required checks and exceptions. [![Recovered event-handler code: string values, conditions, control properties and a VCL method call in their procedure context.](https://www.de-decompiler.com/image/articles/de_decompiler_267/de_decompiler_267_code_decompilation.png)](https://www.de-decompiler.com/image/articles/de_decompiler_267/de_decompiler_267_code_decompilation.png) Recovered event-handler code: string values, conditions, control properties and a VCL method call in their procedure context. ### String results, properties and library calls Calls through an unresolved function pointer can still modify values passed through the stack. Version 26.7 handles string and other output values more accurately in these cases. It avoids substituting an old initial value or a false empty string into a later comparison merely because the complete output-parameter signature is unavailable. Inherited VCL properties receive particular attention. More control setters are recovered as assignments to properties such as `Text` and `Caption`; property reads preserve captured string results instead of repeating access. When a routine cannot reliably be identified as a property accessor, its call, arguments and return value remain visible. Classes with the same name in different libraries are distinguished more accurately, inherited library methods are identified faster, and ambiguous matches are reduced. Loading library databases is faster, with improved stability when reading small databases. ### Integer widths, conversions and more reliable analysis The new version improves local-variable sizes and counters, preserving byte and 16-bit arithmetic more accurately. Signed and unsigned conversions retain the appropriate integer calculations, including 64-bit values. Boolean conversions preserve the original storage width and nonstandard representations of `True`. Reused local variables are less likely to cause an incorrect substitution or a repeated memory read. Round numeric constants use decimal notation where appropriate, while recognized addresses and bit masks remain hexadecimal. This makes ordinary numeric values easier to read without obscuring their machine-level context. Stability fixes address procedures containing embedded data or unusual return instructions, stack handling for uncommon calling conventions and overflow errors during native analysis. Malformed API-call descriptions no longer cause excessive memory allocation; unresolved arguments remain in the output. ### From a recovered VCL form to its event handlers Recent releases expanded the visual side of the investigation. DE Decompiler reads text and binary DFM resources and reconstructs a read-only view of supported VCL forms. Menus, tabs, toolbars, lists and other supported controls retain their stored text, properties and layout without executing the target application or loading its component classes. An analyst can select a control, inspect its recovered properties and navigate to an event handler. The DFM source view adds syntax highlighting, folding, search and navigation history. Support for selected AlphaSkins and TMS controls extends the preview to more real-world applications. The image-viewer plugin can extract form graphics and individual icons from recognized native ImageLists. [![A read-only reconstructed form alongside the project tree and recovered component properties.](https://www.de-decompiler.com/image/articles/de_decompiler_267/de_decompiler_267_forms_visualizer.png)](https://www.de-decompiler.com/image/articles/de_decompiler_267/de_decompiler_267_forms_visualizer.png) A read-only reconstructed form alongside the project tree and recovered component properties. ### Following application logic and database-related code The project tree groups recovered code by unit, class and procedure. Public functions and heuristically discovered private routines can be explored alongside form handlers. Procedure searches, string references and address navigation help connect a visible feature to the code that implements it; the disassembler and HEX Editor provide the underlying instruction and byte views. Database-related application code is one practical example. In the screenshot below, the listing exposes a file-existence check, connection and query component properties, an SQL string and the use of a record count in a condition. These are clues recovered from the application binary. The view does not connect to the database or retrieve its contents. Recovered material can be exported as Pascal units, DFM files, a Delphi project or a combined Pascal listing. Saved VDD analysis databases let an investigation retain recovered structure and renamed symbols. The shared plugin SDK provides a route to custom tooling, including navigation by virtual address and function marking. [![Application code containing connection properties, SQL text and a condition based on a query record count.](https://www.de-decompiler.com/image/articles/de_decompiler_267/de_decompiler_267_sql_db_decompilation.png)](https://www.de-decompiler.com/image/articles/de_decompiler_267/de_decompiler_267_sql_db_decompilation.png) Application code containing connection properties, SQL text and a condition based on a query record count. ### Applications written in Delphi and built with C++Builder DE Decompiler supports VCL applications written in Delphi 3–13 for Win32 and Win64. C++Builder VCL applications also support form recovery and visualization, unit, class and function analysis, event-handler navigation and the other supported tools under the same edition rules. Code from both families is presented as Delphi-like Pascal and exported as PAS/DFM. Library recognition is more extensive for Delphi. C++Builder-specific library RTTI knowledge bases are not yet available, so calls, properties and methods outside the recognized VCL coverage may retain generated names. This affects code-reconstruction quality; it does not remove the other C++Builder analysis capabilities. The detail of native decompilation depends on the instructions and metadata retained in the executable. Original local names may be absent, some types or structures may be inferred only in part, and unidentified calls retain generated names. The recovered listing requires manual analysis and correction before it can be used as source in an IDE. ### Explore DE Decompiler 26.7 Free Lite provides VCL form inspection, native disassembly and string references. Commercial licenses add high-level Pascal code decompilation and the other licensed tools. Download the current release to inspect your application, or use the manual and the complete release notes for the detailed workflow and changes. [Download Free Lite 26.7](https://www.de-decompiler.com/download.htm) · [All changes in 26.7](https://www.de-decompiler.com/news.htm#release-267) · [Read the manual](https://www.de-decompiler.com/documentation.htm) · [Licenses and pricing](https://www.de-decompiler.com/order.htm) November 2, 2026 © Sergey Chubchenko, lead developer of [DE Decompiler](https://www.de-decompiler.com/)