Delphi Decompiler Dede -
| Tool | Description | |------|-------------| | IDR (Interactive Delphi Reconstructor) | Much better than Dede – supports up to Delphi 11, better pseudocode, structure. Free. | | DeDe 3.5 + plugins | Old but still works for legacy Delphi. | | Delphi decompiler by bitmaker (Unreleased) | – | | dnSpy (for .NET Delphi) | Not for native. | | Ghidra / IDA Pro with Delphi scripts | For full disassembly + Delphi RTTI parsing. |
Recommendation: Use IDR instead of Dede unless you need the exact old Dede output format. IDR is actively maintained (last update 2022-2023).
Dede works by parsing Delphi's RTTI (Run-Time Type Information) and debug symbols (if present). Delphi stores DFM resources as a binary stream inside the executable. Dede:
If you want, I can:
DeDe is a legacy reverse-engineering tool designed to analyze and decompile 32-bit executables created with older versions of Borland Delphi (specifically Delphi 2 through 7) and C++Builder
. While it is no longer actively updated, it remains a notable entry in the history of Delphi decompilation due to its speed and ability to reconstruct a project's visual structure. Key Features of DeDe
Unlike modern general-purpose disassemblers, DeDe is specialized for the Delphi framework and its unique metadata structures. DFM Reconstruction : It can extract all
(Delphi Form) files from a target executable, allowing you to view and edit the original UI design within the Delphi IDE. ASM Code Analysis
: It retrieves "published" methods and presents them as well-commented Assembly (ASM) code, including references to strings, class method calls, and imported functions. Project Generation
: DeDe can create a mock Delphi project folder containing retrieved files. However, the files contain assembly code and cannot be recompiled directly back into a working application. Utility Tools
: It includes a PE editor, an RVA (Relative Virtual Address) converter, and a DOI (Delphi Offset Info) builder to assist in low-level binary analysis. Core Limitations
Modern security researchers and developers often find DeDe insufficient for contemporary tasks due to several factors: No High-Level Logic Recovery
: DeDe does not produce readable Pascal source code for application logic; it only provides assembly instructions for the back-end. Version Incompatibility
: It is highly inefficient with modern Delphi versions (post-Delphi 7) and does not support 64-bit architectures. Loss of Metadata
: Because Delphi compiles to native machine code, many original variable and function names are lost during compilation, making any "decompiled" output difficult to interpret without significant manual effort. Stack Overflow Current Status and Alternatives
As of 2026, DeDe is primarily found in software archives and community forums rather than official developer sites. For modern reverse engineering of Delphi binaries, researchers typically use a combined approach with more advanced tools: IDR (Interactive Delphi Reconstructor)
: Often cited as more complete and reliable than DeDe for Win32 executables, with better support for VMTs and RTTI. Ghidra & IDA Pro
: These general-purpose platforms, when paired with Delphi-specific scripts (like
), are the industry standard for analyzing 64-bit and modern Delphi applications. Ultimate Delphi Decompiler
: A commercial utility focused on reconstructing logical structures for legacy modernization. legal considerations
of using these tools for security research or code recovery?
Understanding Delphi Decompilers: Legal Limitations - softacom 27 Jan 2026 —
I'll help you develop a feature for a Delphi decompiler similar to DEDE (DeDe). This feature will extract and display form information, event handlers, and component properties from a Delphi compiled executable.
"""
Delphi Decompiler Feature - Form & Component Extractor
Inspired by DEDE (Delphi Decompiler)
"""
import struct
import re
from dataclasses import dataclass, field
from typing import List, Dict, Optional, BinaryIO
from enum import Enum
class ComponentType(Enum):
TFORM = "TForm"
TBUTTON = "TButton"
TEDIT = "TEdit"
TMEMO = "TMemo"
TLABEL = "TLabel"
TCOMBOBOX = "TComboBox"
TLISTBOX = "TListBox"
TCHECKBOX = "TCheckBox"
TRADIOBUTTON = "TRadioButton"
TPANEL = "TPanel"
TMAINMENU = "TMainMenu"
TTIMER = "TTimer"
UNKNOWN = "Unknown"
@dataclass
class RTTIProperty:
"""Represents a component property from RTTI"""
name: str
value: str
prop_type: str
@dataclass
class EventHandler:
"""Represents an event handler method"""
event_name: str
method_name: str
rva: int # Relative Virtual Address
@dataclass
class Component:
"""Represents a Delphi component/form control"""
name: str
component_type: ComponentType
parent: Optional[str]
properties: Dict[str, RTTIProperty] = field(default_factory=dict)
events: List[EventHandler] = field(default_factory=list)
children: List['Component'] = field(default_factory=list)
@dataclass
class FormInfo:
"""Represents a Delphi form"""
name: str
class_name: str
unit_name: str
components: List[Component] = field(default_factory=list)
class DelphiDecompiler:
"""Main decompiler class for Delphi executables""" delphi decompiler dede
def __init__(self, file_path: str):
self.file_path = file_path
self.file_data = None
self.forms: List[FormInfo] = []
self.string_table: Dict[int, str] = {}
def load_file(self) -> bool:
"""Load the executable file"""
try:
with open(self.file_path, 'rb') as f:
self.file_data = f.read()
return True
except Exception as e:
print(f"Error loading file: e")
return False
def find_delphi_signature(self) -> bool:
"""Detect if file is a Delphi executable"""
signatures = [
b'TPF0', # Delphi 2009+
b'PACKAGEINFO', # Package info
b'System@Sysinit', # Delphi runtime
b'@System@InitUnits', # Unit initialization
]
for sig in signatures:
if sig in self.file_data:
return True
return False
def extract_strings(self) -> None:
"""Extract string table references"""
# Simple string extraction pattern
# Delphi stores strings as length-prefixed
pattern = re.compile(b'\x03([\x20-\x7E]+)\x00')
for match in pattern.finditer(self.file_data):
try:
string_val = match.group(1).decode('ascii', errors='ignore')
offset = match.start()
self.string_table[offset] = string_val
except:
pass
def find_form_resources(self) -> List[tuple]:
"""Find embedded form resource (DFM) data"""
forms = []
# Search for DFM resource patterns
dfm_patterns = [
b'OBJECT ', # DFM object declaration
b'object ', # Lowercase variant
b'POBJECT', # Pascal-style
]
for pattern in dfm_patterns:
pos = 0
while True:
found = self.file_data.find(pattern, pos)
if found == -1:
break
# Extract form name
end_of_obj = self.file_data.find(b'\n', found)
if end_of_obj != -1:
form_line = self.file_data[found:end_of_obj].decode('ascii', errors='ignore')
form_name = form_line.replace('OBJECT ', '').replace('object ', '').strip()
forms.append((found, form_name))
pos = found + 1
return forms
def parse_dfm_data(self, data: bytes) -> List[Component]:
"""Parse DFM (Delphi Form Module) binary/text data"""
components = []
# Convert to string for easier parsing
try:
dfm_text = data.decode('ascii', errors='ignore')
lines = dfm_text.split('\n')
current_component = None
indent_stack = []
for line in lines:
line = line.strip()
if not line:
continue
# Detect component start
if line.upper().startswith('OBJECT'):
# Parse component definition
parts = line.split()
if len(parts) >= 2:
comp_type = parts[1]
comp_name = parts[2] if len(parts) > 2 else "Unnamed"
component = Component(
name=comp_name,
component_type=self._parse_component_type(comp_type),
parent=None
)
components.append(component)
current_component = component
indent_stack.append(component)
# Detect component end
elif line.upper() == 'END':
if indent_stack:
indent_stack.pop()
current_component = indent_stack[-1] if indent_stack else None
# Parse properties
elif current_component and '=' in line:
self._parse_property(line, current_component)
except Exception as e:
print(f"Error parsing DFM: e")
return components
def _parse_component_type(self, type_str: str) -> ComponentType:
"""Convert Delphi type string to ComponentType enum"""
type_upper = type_str.upper()
mapping =
'TFORM': ComponentType.TFORM,
'TBUTTON': ComponentType.TBUTTON,
'TEDIT': ComponentType.TEDIT,
'TMEMO': ComponentType.TMEMO,
'TLABEL': ComponentType.TLABEL,
'TCOMBOBOX': ComponentType.TCOMBOBOX,
'TLISTBOX': ComponentType.TLISTBOX,
'TCHECKBOX': ComponentType.TCHECKBOX,
'TRADIOBUTTON': ComponentType.TRADIOBUTTON,
'TPANEL': ComponentType.TPANEL,
'TMAINMENU': ComponentType.TMAINMENU,
'TTIMER': ComponentType.TTIMER,
return mapping.get(type_upper, ComponentType.UNKNOWN)
def _parse_property(self, line: str, component: Component) -> None:
"""Parse a property line from DFM"""
try:
prop_name, prop_value = line.split('=', 1)
prop_name = prop_name.strip()
prop_value = prop_value.strip().strip('"')
# Detect event handlers
if prop_name.lower().endswith('on'):
# Event handler reference
event_handler = EventHandler(
event_name=prop_name,
method_name=prop_value,
rva=0 # Would need actual RVA calculation
)
component.events.append(event_handler)
else:
# Regular property
prop_type = self._guess_property_type(prop_value)
rtti_prop = RTTIProperty(
name=prop_name,
value=prop_value,
prop_type=prop_type
)
component.properties[prop_name] = rtti_prop
except Exception:
pass
def _guess_property_type(self, value: str) -> str:
"""Guess property type from value"""
if value.isdigit():
return 'Integer'
elif value.upper() in ['TRUE', 'FALSE']:
return 'Boolean'
elif value.startswith('$') and len(value) > 1:
return 'Hex'
else:
return 'String'
def find_event_handlers(self) -> Dict[str, List[int]]:
"""Find event handler addresses in code section"""
handlers = {}
# Pattern for Delphi method references
method_patterns = [
rb'\x68([\x00-\xFF]4)', # push address (DELPHI)
rb'\xB8([\x00-\xFF]4)', # mov eax, address
]
for pattern in method_patterns:
for match in re.finditer(pattern, self.file_data):
try:
address = struct.unpack('<I', match.group(1))[0]
# Look for method name nearby
method_name = self._find_method_name(match.start())
if method_name:
handlers.setdefault(method_name, []).append(address)
except:
pass
return handlers
def _find_method_name(self, position: int) -> Optional[str]:
"""Find method name near given position"""
# Look for Pascal string format (length byte + string)
search_range = 100
start = max(0, position - search_range)
end = min(len(self.file_data), position + search_range)
for offset in range(start, end):
if offset + 1 >= len(self.file_data):
continue
str_len = self.file_data[offset]
if 1 <= str_len <= 100: # Reasonable string length
try:
name = self.file_data[offset+1:offset+1+str_len].decode('ascii', errors='ignore')
if name and name[0].isalpha():
return name
except:
pass
return None
def decompile(self) -> bool:
"""Main decompilation process"""
print(f"[*] Loading file: self.file_path")
if not self.load_file():
return False
print("[*] Checking Delphi signature...")
if not self.find_delphi_signature():
print("[!] Warning: Delphi signature not found")
print("[*] Extracting strings...")
self.extract_strings()
print("[*] Finding form resources...")
form_resources = self.find_form_resources()
print(f"[*] Found len(form_resources) potential form(s)")
for offset, form_name in form_resources:
print(f"\n[*] Processing form: form_name")
# Extract form data (simplified)
end_offset = self.file_data.find(b'END', offset)
if end_offset != -1:
form_data = self.file_data[offset:end_offset+3]
components = self.parse_dfm_data(form_data)
form_info = FormInfo(
name=form_name,
class_name=f"Tform_name",
unit_name="", # Would need unit detection
components=components
)
self.forms.append(form_info)
print("[*] Finding event handlers...")
event_handlers = self.find_event_handlers()
print(f"[*] Found len(event_handlers) event handler(s)")
return True
def generate_report(self) -> str:
"""Generate a decompilation report"""
report = []
report.append("=" * 60)
report.append("DELPHI DECOMPILER REPORT - DEDE STYLE")
report.append("=" * 60)
report.append(f"File: self.file_path")
report.append(f"Forms Found: len(self.forms)")
report.append("")
for i, form in enumerate(self.forms):
report.append(f"\n--- FORM i+1: form.name ---")
report.append(f"Class: form.class_name")
report.append(f"Components: len(form.components)")
report.append("")
for comp in form.components:
report.append(f" [+] Component: comp.name (comp.component_type.value)")
if comp.properties:
report.append(f" Properties:")
for prop_name, prop in list(comp.properties.items())[:10]: # Limit display
report.append(f" - prop_name = prop.value")
if comp.events:
report.append(f" Events:")
for event in comp.events:
report.append(f" - event.event_name -> event.method_name")
if comp.children:
report.append(f" Children: len(comp.children)")
return "\n".join(report)
def export_to_dcr(self, output_file: str) -> None:
"""Export to DCR (DeDe format) compatible file"""
with open(output_file, 'w') as f:
f.write("[Delphi Decompiler Export]\n")
f.write(f"File: self.file_path\n\n")
for form in self.forms:
f.write(f"[Form: form.name]\n")
f.write(f"Class: form.class_name\n")
f.write("Components:\n")
for comp in form.components:
f.write(f" comp.name = comp.component_type.value\n")
for prop in comp.properties.values():
f.write(f" prop.name = prop.value\n")
f.write("\n")
If you search "Delphi decompiler DeDe alternative," the most frequent answer is IDR. It is essentially the spiritual successor to DeDe. It supports Delphi versions up to Delphi 10.3 and even some 64-bit binaries. IDR recovers forms, events, and RTTI just like DeDe but with a cleaner interface.
Decompilation may violate software licenses or laws (e.g., DMCA, EU Software Directive). Use Dede only on:
DeDe offers several features that bridge the gap between raw binary and source code:
Understanding the DeDe Delphi Decompiler The DeDe Delphi Decompiler is a specialized reverse engineering tool designed to analyze and disassemble executables (EXE) and dynamic link libraries (DLL) compiled with Borland/Embarcadero Delphi. Created by the developer known as DaFixer, DeDe became a staple in the reverse engineering community for its ability to reconstruct high-level project elements that general-purpose disassemblers often miss. Core Capabilities of DeDe
While it is technically impossible to perfectly replicate original source code from a native machine-code binary, DeDe provides a near-facsimile that is invaluable for analysis.
UI Reconstruction: DeDe extracts and previews Delphi Form files (DFM), allowing users to see the original interface layout, object properties, and event handler connections.
Class Hierarchy Analysis: The tool rebuilds class hierarchies and Virtual Method Tables (VMTs), providing a clear map of how the software's objects interact.
Disassembly with Context: It presents published methods in well-commented Assembly (ASM) code. These comments often include references to strings, imported function calls, and components, making the low-level code much easier to read than raw hex.
Project Skeleton Generation: Users can generate a Delphi project folder containing .dpr and .pas files. Note that while the project structure is restored, the .pas files contain ASM code rather than re-compilable Pascal source. Common Use Cases
DeDe is primarily used as an exploratory and recovery tool rather than a way to "steal" code.
Lost Source Code Recovery: It is frequently used by developers to recover logic or UI structures from their own legacy applications when the original source files have been lost.
Legacy System Debugging: Maintenance teams use it to understand the behavior of ancient proprietary software that lacks documentation.
Security Research: Analysts use DeDe to check for malicious code or vulnerabilities within Delphi-based binaries.
Learning and Interoperability: It helps developers understand how certain compiled Delphi programs achieve specific tasks to ensure their own new software can interact with them correctly. Versions and Availability
The development of DeDe reached its peak with version 3.50.02 Build 1619. While the original developer eventually released the source code and ceased active updates, the tool remains available in various software archives and repositories. Latest Official Version 3.50.02 Build 1619 Supported Compilers Delphi 3, 4, 5, 6, and early C++Builder/Kylix versions License Type Freeware / Open Source Operating System Windows (32-bit focus) Modern Limitations
Despite its popularity, DeDe has notable limitations in the modern development landscape. It struggles with 64-bit binaries and more recent versions of the Delphi compiler, which have introduced complex optimizations that DeDe was not built to handle. For newer applications, reverse engineers often turn to tools like the Interactive Delphi Reconstructor (IDR) or use IDA Pro with specialized Delphi signatures. DeDe - Download - Softpedia
The Mysterious Case of the Lost Code
Alex had always been fascinated by reverse engineering and the art of decompiling. As a young programmer, he spent countless hours exploring the depths of the Delphi programming language and its associated tools. One day, while browsing through an online forum, Alex stumbled upon a legendary tool known as DeDe, a Delphi Decompiler created by the enigmatic "DeDe Team".
Intrigued, Alex downloaded DeDe and began to experiment with it. He started by decompiling simple Delphi programs to understand how the tool worked. As he gained confidence, he decided to try decompiling a more complex application, a proprietary software called "SecureCalc" that was rumored to be used by a prominent financial institution.
The challenge was on. Alex launched DeDe and loaded the SecureCalc executable. The decompiler quickly got to work, analyzing the code and reconstructing the original Delphi source. As Alex navigated through the decompiled code, he was amazed by the accuracy and detail of the results. DeDe had successfully recovered the program's logic, including complex algorithms and data structures.
As Alex dug deeper, he began to uncover some interesting secrets. It turned out that SecureCalc was not just a simple calculator, but a full-fledged financial analysis tool with advanced features like encryption and secure data storage. The more Alex explored, the more he became convinced that SecureCalc was more than just a ordinary program.
However, his excitement was short-lived. As he continued to investigate, Alex encountered a series of encrypted code blocks that DeDe couldn't seem to crack. The encrypted sections were heavily obfuscated, making it nearly impossible for Alex to understand their purpose. He tried various techniques to bypass the encryption, but to no avail.
Determined to solve the puzzle, Alex turned to online forums and communities, seeking help from fellow programmers and reverse engineers. After weeks of collaboration and brainstorming, they finally discovered a weakness in the encryption scheme. With the encryption broken, Alex was able to access the previously inaccessible code.
The breakthrough led to a shocking revelation. The SecureCalc application was not just a financial tool, but a comprehensive data analysis platform used by the financial institution to detect and prevent money laundering. The encrypted code blocks contained critical components of the platform's anti-money laundering (AML) engine.
The discovery earned Alex a reputation in the reverse engineering community, and he became known as one of the few individuals who had successfully decompiled and analyzed a highly secured Delphi application. His findings were met with both praise and concern, as the financial institution was forced to reevaluate the security of their platform.
The story of Alex and DeDe serves as a testament to the power of reverse engineering and the importance of understanding the inner workings of complex software systems. As the legend of DeDe continues to grow, so does the interest in the mysterious DeDe Team, who remain anonymous but continue to develop and improve their powerful decompiler.
Epilogue
Years later, Alex would go on to become a leading expert in reverse engineering and Delphi programming. He would write articles and give talks about his experiences with DeDe and other decompilers. Although he never publicly revealed the identity of the DeDe Team, he continued to use DeDe and other tools to analyze and understand the intricacies of complex software systems.
The DeDe Team remained a mystery, but their creation continued to inspire and influence a new generation of programmers and reverse engineers. The legend of DeDe lived on, a reminder of the power and importance of reverse engineering in the world of software development. | Tool | Description | |------|-------------| | IDR
DeDe (Delphi Decompiler) is a legacy 32-bit tool developed by DaFixer that specializes in recovering metadata, forms, and method information from Delphi 2 through 7 executables. It aids in reverse engineering by reconstructing UI elements and generating assembly-level project files, rather than reconstructing high-level source code. For more information, visit the Softpedia Download. DeDe - Download - Softpedia
Introduction
Delphi Decompiler Dede is a software tool designed to reverse-engineer and decompile programs written in Delphi, a popular object-oriented programming language. Dede is a free and open-source decompiler that can help developers understand and analyze the internal workings of Delphi applications. This paper provides an overview of Dede, its features, and its uses.
What is Delphi?
Delphi is a high-level, compiled, strongly typed language developed by Embarcadero Technologies. It is widely used for building Windows desktop applications, mobile apps, and web applications. Delphi is known for its fast development capabilities, large standard library, and strong support for object-oriented programming.
What is a Decompiler?
A decompiler is a software tool that takes compiled code as input and generates source code in a high-level programming language as output. Decompilers are used to reverse-engineer software, understand its internal workings, and analyze its behavior. Decompilers can be useful for various purposes, such as:
Delphi Decompiler Dede
Dede is a free and open-source decompiler for Delphi programs. It was first released in 2004 and has since become one of the most popular decompilers for Delphi. Dede can decompile Delphi programs from version 3 to the latest version, including programs compiled with the .NET framework.
Features of Dede
Some of the key features of Dede include:
How Dede Works
Dede uses a combination of disassembly and decompilation techniques to recover the source code from a compiled Delphi program. Here is a high-level overview of the decompilation process:
Uses of Dede
Dede has various uses, including:
Conclusion
Delphi Decompiler Dede is a powerful tool for reverse-engineering and decompiling Delphi programs. Its ability to decompile programs from various Delphi versions and .NET framework makes it a valuable asset for developers, researchers, and educators. Dede's features, such as syntax highlighting and support for various output formats, make it a user-friendly tool for analyzing and understanding compiled Delphi programs.
Future Work
Future work on Dede could include:
References
Exploring the Classic: A Guide to the DeDe Delphi Decompiler
If you’ve ever found yourself with an old Delphi executable and a missing source code folder, you’ve likely come across DeDe (DaFixers Delphi Decompiler)
. While it is a legendary tool in the reverse engineering community, it comes with specific strengths and modern-day limitations that every developer should know. What is DeDe?
DeDe is a specialized decompiler designed to analyze files compiled with older versions of Delphi (typically Delphi 2 through 7
). Unlike modern languages like Java or .NET, which compile to bytecode that is easily "unbaked," Delphi compiles directly to native machine code.
Because of this, DeDe doesn't magically recreate your original
source files. Instead, it provides a highly detailed "skeleton" of the application. Key Features and Capabilities
DeDe is famous for its speed and its ability to pull meaningful data out of a binary: UI Recovery: It can extract all
, allowing you to see the exact layout, properties, and components of every form in the application. Event Handler Mapping: Dede works by parsing Delphi's RTTI (Run-Time Type
It identifies which procedures are linked to which buttons or menu items, saving you hours of hunting through assembly. Commented Assembly: While it doesn't give you Pascal code, it provides commented ASM code
that includes references to strings, imported functions, and class methods. Project Reconstruction: It can generate a folder structure with files, giving you a head start on rebuilding the project. The Reality Check: Limitations
Before you download DeDe from an archive, keep these modern constraints in mind: No High-Level Code:
get back your original Pascal logic; you'll get assembly code that requires a strong understanding of low-level programming to read. Age Matters:
DeDe was built for the 32-bit era. It struggles or fails entirely with modern 64-bit binaries
or applications built with newer versions like Delphi XE and beyond. Abandoned Development:
There is no longer an "official" site for DeDe; it is largely considered abandonware and must be sourced from software archives or community repositories. Modern Alternatives
If DeDe isn't cutting it for your specific file, consider these alternatives: IDR (Interactive Delphi Reconstructor): Often considered the successor to DeDe,
supports newer Delphi versions (up to XE4) and offers a more interactive analysis environment. MiTeC DFM Editor:
If you only need to peek at or edit the user interface without touching the code, the MiTeC DFM Editor is a robust, standalone tool.
DeDe remains a "gold standard" for legacy 32-bit Delphi reverse engineering. It is an invaluable tool for recovering lost UI layouts
or understanding how a 20-year-old application functions, but it’s best used as a starting point rather than a one-click solution for code recovery. reading the assembly output DeDe generates, or are you looking for a guide on a different reverse engineering tool Decompiling Delphi (1/3) - ThoughtCo
DeDe is a specialized decompiler for applications built with Delphi (versions 2 through 6). While it doesn't provide fully recompilable source code, it is excellent for recovering UI forms and analyzing application logic through assembly. 1. Getting Started with DeDe
To begin using DeDe, you can find it on various archives or software repositories since it is no longer actively updated.
Load the Target: Open DeDe and use the File | Open menu to load a Delphi executable (.exe), DLL, or BPL.
Analyze the File: Click the Analyze button. DeDe will scan the binary for Delphi-specific metadata, such as the Virtual Method Table (VMT) and published methods. 2. Key Features and Outputs
Once analysis is complete, DeDe provides several tabs to explore the application:
DFM Files (Forms): You can view and extract all .dfm files. These contain the UI layout and property settings (e.g., button captions, positions). You can even open and edit these directly in Delphi.
Published Methods: DeDe lists event handlers (like OnClick events). It provides these in commented ASM (Assembly) code, often including references to strings, imported functions, and class method calls.
Project Creation: Use the Make Project feature to generate a Delphi project folder containing the retrieved .dfm, .pas, and .dpr files. Note that the .pas files contain assembly code and cannot be recompiled as-is. 3. Advanced Tools in DeDe
DeDe includes several built-in utilities for deeper analysis:
Disassemble Proc: If you know a specific Relative Virtual Address (RVA), you can manually disassemble any procedure via the Tools | Disassemble Proc menu.
Symbol Files (DSF): You can load .dsf files (DeDe Symbol Files) via File | Load Symbol File. These help DeDe identify and comment on exports from BPL libraries, similar to FLIRT signatures in other tools.
Helper Tools: The interface includes a PE Editor, RVA Converter, and DOI Builder (Delphi Offset Info) to help navigate the binary structure. 4. Limitations and Modern Alternatives Because DeDe is a legacy tool, it has specific constraints:
Version Limit: It is most effective for 32-bit executables from older Delphi versions (up to version 6 or 7).
No Logic Recovery: It does not recover high-level Pascal logic; you must be comfortable reading x86 assembly to understand "what happens" after a button click.
For more modern or complex Delphi applications, developers often use IDR (Interactive Delphi Reconstructor) for better class reconstruction or Ghidra with specialized Delphi scripts.
Are you trying to recover a specific UI form or are you looking to understand the logic of an older application? DeDe - Download - Softpedia