Vallenta Studio

Features · Roadmap · Changelog · Report an issue

A Visual Studio Code extension that provides comprehensive Delphi development support, enabling you to edit, build, and debug Delphi projects directly within VS Code.

Vallenta Designer is now available — the visual form designer for VCL .dfm files, published as source under the MIT license at github.com/Vallenta/Designer. It is a separate Delphi application, built with each Delphi version it is used with; the path to the built VallentaDesigner.exe is entered per version under Form Designer in the Vallenta Studio settings. Free during the beta — no Pro subscription required.

Features

The extension is available in two tiers. See the full feature matrix for a tier-by-tier comparison.

Free (with registered account)

• Project Explorer - Manage multiple Delphi projects (.dproj) and packages (.dpk) in a dedicated sidebar with recent project support
• Build System - Build, clean, and rebuild projects using MSBuild with configuration/platform selection and build toolbar. Compiler errors, warnings, and hints are parsed into the Problems panel
• Syntax Highlighting - Full Object Pascal TextMate grammar including keywords, types, comments, strings, and compiler directives
• Code Intelligence (LSP) - Go to Definition, hover information, code completion, and document symbols/outline powered by a built-in Language Server
• Find Symbol - Workspace symbol picker (Ctrl+T or editor right-click "Find Symbol…") for classes, records, interfaces, methods, properties, and unit-level symbols
• Find All References - Semantic, scope-aware reference search (Shift+F12) across the project, including matches inside .dfm/.fmx form files
• Toggle Form / Source - Press F12 (or use the CodeLens at the top of the file) to swap between a .pas unit and its sibling .dfm/.fmx form. The Source Files view shows an inline [DFM]/[FMX] tag for units with a form
• Semantic Highlighting - Resolver-driven coloring that distinguishes identifiers by meaning — types, classes, interfaces, methods, properties, fields, parameters, and enum members — plus same-identifier occurrence highlighting
• Structural Highlighting - Block keywords (begin/end, if, for, case, try…) colored by nesting level; the whole construct highlights when your cursor is on one of its keywords, and control-flow keywords (exit, break, continue, raise) are emphasized
• Preprocessor Support - Full {$IFDEF}, {$DEFINE}, {$INCLUDE} evaluation with inactive region visualization (grayed-out code)
• Code Folding - Routines, types, sections, uses clauses, blocks, comments, {$IFDEF} branches and {$REGION} blocks fold; Fold All Regions folds the {$REGION} blocks, whose captions can also be shown as minimap labels
• File Encoding - Detects ANSI-encoded Pascal files and offers one-click conversion to UTF-8 with BOM
• Session Persistence - Saves and restores open tabs when switching between projects

Pro (with paid subscription)

All Free features, plus:

• Source-Level Debugging - Full source-level debugging with breakpoints, stepping, variable inspection, and call stacks. Press F5 to start — no configuration needed.
• Watch & Hover Evaluation - Call methods on your objects, read properties (including inherited ones), drill into interface and class references, and see sets, enums and Booleans in Delphi form — right from the Watch panel and on hover; a [Properties] node lists an object's getter-backed properties
• Delphi Exception Handling - Debugger breaks on raised Delphi exceptions and unwinds the Delphi exception stack, showing the full call path back to the raise site merged with the native frames, and a Delphi Exception Filters view lets you skip chosen exception types by name or pattern
• Natvis Type Visualization - Version-specific natvis files for displaying Delphi types (strings, arrays, variants, objects) in the debugger
• Go to Declaration / Implementation - Jump between interface declarations and implementation bodies (Shift+Ctrl+Up / Shift+Ctrl+Down)
• Semantic Validation - Compiler-style diagnostics that detect undefined types, methods, and variables with configurable severity
• Rename Symbol - Rename a symbol with F2 and every use updates across the project in one step — declaration, implementation, and all references, including inside .dfm/.fmx forms. Unsafe or conflicting renames are refused with a clear explanation
• Highlight Color Editor - Recolor semantic and structural highlighting with visual color-picker dialogs and a live preview, instead of hand-editing JSON
• Folded Region Captions - A folded {$REGION} block shows its caption framed or as a badge, with the directive syntax dimmed
• Regions in the Outline - {$REGION} blocks appear as groups in the Outline view, breadcrumbs, Go to Symbol and sticky scroll
• Breakpoint Persistence - Breakpoints are saved and restored per project
• Project Options Editor - Edit project configuration directly within VS Code, including per-configuration build settings, per-configuration/platform debugger environment variables, and a visual editor for referenced option sets (.optset)
• Copy Variable as Tree - Right-click in the debugger Variables or Watch view to copy the expanded variable hierarchy to the clipboard (up to 2 levels deep, 2000 nodes)
• Group Builds - Build all projects in a project group at once
• Linux Remote Debugging - Build Linux64 on Windows, deploy to a Linux machine and debug it there with breakpoints, stepping and watch evaluation. Machines are paired once and referenced by name; per build configuration you choose the target, the working directory and the files deployed alongside the program

Requirements

• Delphi - A valid Delphi installation (Delphi 10.x, 11.x, 12.x or 13.x)
• C/C++ Extension - Required for debugging (ms-vscode.cpptools). VS Code installs this automatically when you install the Vallenta Studio extension.

Installation

1. Install the extension from the VS Code Marketplace
2. Open a folder in VS Code to use as your workspace (see Workspace Setup below)
3. The extension auto-detects your Delphi installation and configures paths automatically

Getting Started

Workspace Setup

The extension requires an open workspace folder in VS Code. It stores project references and settings in a .vallenta folder inside your workspace root.

The workspace folder does not have to be the actual Delphi project folder. The recommended practice is to open a parent directory that covers multiple Delphi project folders. For example:

C:\MyWork\                    <-- open this folder as your VS Code workspace
+-- .vallenta\                <-- extension stores project list and settings here
+-- ProjectA\
¦   +-- ProjectA.dproj
¦   +-- ...
+-- ProjectB\
¦   +-- ProjectB.dproj
¦   +-- ...
+-- SharedLibrary\
    +-- ...

This way you can manage multiple Delphi projects within a single workspace.

Delphi Detection

On first startup, it scans the Windows Registry for installed Delphi versions and selects the latest one. To switch to a different Delphi version, open the settings dialog (top right on the Project Explorer) and select the Delphi version from the dropdown list.

Information regarding Delphi 2007

Delphi 2007 is detected beside the modern releases, and its projects build, index, run and debug from the extension. The Project Options editor opens a Delphi 2007 project read-only, because the extension does not write the 2007 project file format; project options are changed in the Delphi 2007 IDE. Two features are not available for such a project: the New Project wizard, for the same reason, and the Form Designer, which needs Delphi 11.3 or later.

Delphi 2005, 2006, 2009, 2010 and XE to XE8 are not detected. Support for one of them is added on request.

Adding Projects

1. Open the Vallenta Studio view in the Activity Bar (sidebar)
2. Click Add Project to browse and select a .dproj or .dpk file
3. Or use Add Project Group to load all projects from a .groupproj file

Building

1. Set the active project by clicking on it in the Project Explorer
2. Select the build configuration (Debug/Release) and target platform (Win32/Win64) in the Build toolbar
3. Click the Build button in the Build toolbar — one click, no VS Code tasks.json configuration required
4. Build output streams in real-time to the Build Output panel; errors and warnings appear in the Problems panel

Debugging (Pro)

1. Build the active project with Debug configuration to include debug information
2. Press F5 (or click Debug in the Build toolbar) to start debugging

That's it — no launch.json or tasks.json needed. The extension automatically:

• Generates the debug symbols required by the debugger
• Generates version-specific natvis visualizers for Delphi types
• Launches the debugger with the correct paths and settings

Use Ctrl+F5 to run without debugging.

Debugging capabilities:

• Source-level breakpoints
• Step over / into / out
• Local variable and parameter inspection
• Call stacks with function names and line numbers
• Natvis type visualization for Delphi strings, arrays, variants, and objects
• Copy expanded variable trees to the clipboard via right-click in Variables / Watch
• Delphi exception handling — the debugger automatically breaks on raised Delphi exceptions (identified by the 0x0EEDFADE exception code), reads the exception class name and message, and unwinds the Delphi exception stack so the call stack shows the full path back to the raise site merged with the native C++ frames. Enabled by default via the All Delphi Exceptions breakpoint filter in the Breakpoints view; toggle All Exceptions there to also break on non-Delphi (SEH) exceptions

Linux Development (Pro)

A project with the Linux64 platform is compiled on Windows by Delphi's Linux compiler, then deployed to and debugged on a Linux machine. Three things are set up once; after that F5 behaves as it does on Windows.

1. Run the agent on the Linux machine. Remote debugging is driven by VallentaAgent, one static binary that needs no root and installs nothing outside the user's home directory:

curl -fsSL https://github.com/Vallenta/VallentaAgent/releases/latest/download/install.sh | sh

Vallenta Studio: Copy Linux Agent Install Command puts that line on the clipboard. The agent prints a pairing token when it starts. lldb-server is not bundled — the distribution supplies it, and the agent names the package to install for the distribution it detects.

2. Register the machine. Vallenta Studio: Add Linux Target takes the host, port and printed token and pairs once. Registered machines are listed in the Linux Targets panel with what each one reported: agent version, lldb-server version, distribution and glibc. Targets belong to the workspace and are referenced by name, so no host names or ports are written into project files.

3. Provide a sysroot. A Linux64 link needs the target distribution's libraries. The Linux Distributions panel downloads and prepares them per distribution, and the target's distribution decides which one a build links against; a target without one stops the build before the compiler starts. The build links against that sysroot alone — a Linux SDK registered in the IDE takes no part in it. A library the project links against that the catalogue does not carry is named under Additional packages on the distribution, as its runtime package and its -dev package (libxml2 libxml2-dev on Ubuntu 24.04, libxml2-16 libxml2-dev on 26.04), and is downloaded with the next Prepare. A name the release does not carry is reported with the names it does have.

The debug engine is fetched on demand: the extension matches lldb-dap to the lldb-server version the target reports, so both ends speak the same protocol.

The program starts with the environment of the agent process, so a variable exported in the shell the agent was started from reaches it; env in the launch configuration adds to that and overrides variables of the same name.

Each session writes its startup to the Vallenta Linux Debug output channel, which opens with it: debug metadata, source locations, the agent connection and session, deploy and launch, and the transfer check — each with the time it took, and a total. vallenta.studio.linux.trace adds the DAP and agent traffic to the same channel.

Deployment Options

Open Deployment Options from a project's context menu in the Projects view. The editor is scoped by build configuration: pick a configuration on the left, and the settings on the right apply to it. All configurations holds the values every configuration inherits, and a configuration that sets nothing of its own shows the inherited value greyed out.

Per configuration you set:

• Linux target — the machine to deploy to. It also supplies the sysroot the Linux64 build links against, so changing it changes what the project compiles against. The indicator beside it shows whether the target answered; the check runs when you open the editor, switch configuration or pick a target.
• Working directory — where the program is placed and run, relative to the agent's scratch root. Left empty, the program runs in the scratch root itself.
• Deployed files — files copied to the target before the program starts, one entry per file, folder or pattern such as data/**, inside the project directory or outside it. + Add Path adds an entry by its typed path: relative to the project directory, absolute, or with $(NAME) macros such as $(BDSCOMMONDIR), expanded for the build configuration. Add Files… and Add Folder… pick entries in a dialog instead. A picked path is stored through the macro of the Delphi folder or IDE environment variable it lies in, otherwise relative to the project directory, and as an absolute path only on another drive or a network share. A folder or pattern keeps its structure relative to the project directory, or relative to its own folder when that lies outside the project directory.

Each entry shows where its files land, or why it cannot be deployed. Selecting it opens its editor: the local path with File… and Folder… to pick a replacement, the file the path resolves to (on All configurations, one line per build configuration), updated while the path is typed, a subfolder, a different remote name, and whether an existing file is overwritten, the file is made executable and the entry is enabled.

The Live Target View at the bottom shows the resulting layout on the target, including the program itself, which the debugger uploads without an entry. A file that cannot be deployed — a path matching nothing, or a macro without a value — is reported there and stops the session before the target is contacted.

Deploy Files in the Debug button's menu sends the same files without starting the program: the configuration's deployment entries plus the built executable. The Debug menu follows the selected platform — on Linux64 it offers this instead of Attach to Process…, and Convert Debug Symbols becomes Regenerate Debug Metadata, which rebuilds the type information the Linux debugger reads from the executable. A debug session rebuilds that information by itself whenever the program is newer, so this is for repeating a generation that failed.

Projects that already carry Delphi's own deployment entries can take them over with Import from Delphi. The import is one-time and additive, covers the Linux64 entries only, and reports anything it skipped.

Debugging on Linux

F5 builds the project if needed, deploys it, and starts the session. Breakpoints, stepping, call stacks and variable inspection work as they do on Windows, including Delphi strings, dynamic arrays, sets, records, classes and interfaces. Delphi exceptions break at the raise site with the class name and message. Program output goes to an integrated terminal, so a program that reads from standard input can be driven from it.

Source files stay on Windows — nothing but the program and the files you list is copied to the target.

Code Intelligence

The built-in LSP server starts automatically when a project is activated and provides:

• Go to Definition (Ctrl+Click) - Navigate to symbol declarations
• Go to Declaration / Implementation (Shift+Ctrl+Up / Shift+Ctrl+Down) - Jump between interface and implementation (Pro)
• Find Symbol (Ctrl+T) - Workspace-wide symbol search
• Find All References (Shift+F12) - Semantic reference search across the project, including matches inside .dfm/.fmx form files
• Rename Symbol (F2) - Rename a symbol and every reference to it across the project, including type members (Pro)
• Overload Resolution - Hover and Ctrl+Click on an overloaded routine narrow to the specific overload by matching argument types
• Hover - View type information and symbol details
• Code Completion - Type-aware member suggestions after the dot operator
• Document Symbols - Outline view and breadcrumb navigation; {$REGION} blocks as groups when enabled (Pro)
• Code Folding - Folding ranges for routines, types, sections, uses clauses, blocks, statements, comments and {$IFDEF} branches, independent of the active defines
• Semantic Highlighting - Context-aware syntax coloring
• Diagnostics - Errors, warnings, and hints for undefined types, methods, and variables (Pro)
• Inactive Regions - Preprocessor-excluded code shown with reduced opacity

Extension Settings

Vallenta Studio Environment

Debugging

Linux (Pro)

Targets and distributions are managed by their panels rather than edited by hand.

Editor

LSP Server

MCP Server

MCP Server for AI Agents (Pro)

Vallenta Studio can host a local MCP server so AI agents work with your Delphi code through the same engine the IDE uses — instead of grepping raw text and guessing at Delphi semantics (uses-clause visibility, case insensitivity, {$IFDEF} regions).

Tools (16): find_symbol, find_references, find_implementations, go_to (definition/implementation/declaration), get_symbol_info, get_completions, get_document_symbols, get_diagnostics, get_inactive_regions, get_projects, get_project_info, set_build_config, build, cancel_build, get_build_output, ping.

The server also advertises usage instructions over the protocol, so a connecting agent is told which tool answers which question — and that Pascal is case-insensitive, that visibility follows the uses clause, and that an inactive {$IFDEF} branch is not dead text — rather than falling back on text search.

On by default for a Pro subscription; clear vallenta.studio.mcp.enabled to stop hosting it. The server listens on 127.0.0.1 only and requires a bearer token; nothing is reachable from the network and no credential is written into your workspace.

GitHub Copilot (agent mode): on VS Code 1.102 or newer the server is discovered automatically — the Vallenta Studio tools appear in agent mode once the server is running. Older VS Code versions can still use external agents via the connect command below.

Claude Code: the MCP server for AI agents tile on the settings page registers it in one click — Register with Claude Code adds the server for the current workspace, and Remove registration takes it out again. Re-run it after changing the port. Registration drives your own claude CLI when it is on PATH, and otherwise the copy bundled with the Claude Code VS Code extension, so having either one installed is enough. If you have neither, Copy connect command gives you the claude mcp add … line to run where the CLI is. Either way the access token lands in Claude's user-private configuration, outside your repository. MCP: Show Server Status shows the current URL.

Commands

Keyboard Shortcuts

Supported File Types

Known Limitations

• Form Designer: VCL .dfm forms open visually in the external designer (Pro plan; Open in Form Designer on a .dfm/.pas, with event/field/rename coupling into the unit) — .fmx files still open as text; the FMX host is a later phase
• Windows only — the extension requires a local Delphi installation on Windows. Linux64 projects are deployed to and debugged on a Linux machine running VallentaAgent; other target platforms can be cross-compiled, but deployment to them is not handled by the extension
• LSP does not yet support: Code Actions, Code Formatting

Feedback and Issues

Found a bug or have a feature request? Please open an issue on this repository.

Trademark Notice

Delphi is a registered trademark of Embarcadero Technologies, Inc. Vallenta Studio is an independent product and is not affiliated with, authorized, or endorsed by Embarcadero Technologies.

License

See LICENSE for details.