A community-driven registry for Claude, Cursor, Windsurf, Cline & more. Not affiliated with Anthropic.
Are you the author? Sign in to claim
Dext - Modern Full Stack Framework for Delphi
Modern Full-Stack Development for Delphi
[!IMPORTANT] Dext Framework is currently in Version 1 Release Candidate (RC2).
Dext Framework is a native and integrated ecosystem for Delphi development.
It brings together Dependency Injection, ORM, Web Pipeline, and Testing into a single, high-performance architecture. Designed to eliminate the need for connecting isolated libraries and to drastically reduce boilerplate code, Dext handles the infrastructure complexity so your team can focus strictly on business logic.
Dext was built to bridge the perception and architectural gap between Delphi and modern platforms like .NET Core. If your team is considering migrating a legacy VCL/FMX system to another modern stack due to the lack of modern enterprise patterns, Dext offers a complete native alternative without the cost, risk, and time of rewriting your entire codebase.
We provide full functional parity with modern ASP.NET Core & Entity Framework Core patterns, while leveraging native compilation (no JIT, zero cold starts, and minimal memory footprint).
Explore our detailed comparison and capability references:
Dext was specifically designed to solve the real-world pain points faced by Delphi developers:
[DataApi] attribute.TThread class.See how Dext's structure simplifies complex flows into clean, typed, and object-oriented code. Exploring the framework's pillars:
Creating a high-performance endpoint integrated with Dependency Injection requires minimal effort:
program MyAPI;
uses Dext.Web;
begin
var App := WebApplication;
// Simple endpoint
App.MapGet('/hello', function: string
begin
Result := 'Hello from Dext! Modern full-stack for Delphi.';
end);
// Endpoint with native Automatic Dependency Injection (DI) and Model Binding
App.MapPost<TUserDto, IEmailService, IResult>('/register',
function(Dto: TUserDto; EmailService: IEmailService): IResult
begin
EmailService.SendWelcome(Dto.Email);
Result := Results.Created('/login', 'User successfully registered');
end);
App.Run(8080);
end.
Automatic mapping via Convention over Configuration and structured properties for advanced relational mapping:
[Table]
[DataApi('/api/orders')] // Automatically exposed as a REST API (Zero-Code API)!
TOrder = class
private
FId: IntType;
FStatus: Prop<TOrderStatus>;
FNotes: StringType;
FTotal: Nullable<CurrencyType>;
FItems: Lazy<IList<TOrderItem>>;
public
[PK, AutoInc]
property Id: IntType read FId write FId;
property Status: Prop<TOrderStatus> read FStatus write FStatus;
property Notes: StringType read FNotes write FNotes;
// Smart Types to natively handle nulls, validation, and Lazy Loading
property Total: Nullable<CurrencyType> read FTotal write FTotal;
property Items: Lazy<IList<TOrderItem>> read FItems write FItems;
end;
No more magic strings or broken queries at runtime. Dext generates the Abstract Syntax Tree (AST) of your code:
// Complex query with Joins and Filters interpreted as clean code
var O := Prototype.Entity<TOrder>;
var Orders := DbContext.Orders
.Where((O.Status = TOrderStatus.Paid) and (O.Total > 1000))
.Include('Customer') // Eager Loading
.Include('Items')
.OrderBy(O.Date.Desc)
.Take(50)
.ToList;
// High-performance Bulk Update directly in the DBMS without loading records into memory
DbContext.Products
.Where(Prototype.Entity<TProduct>.Category = 'Outdated')
.Update
.Execute;
The complexity of TThread transformed into modern asynchronous chained pipelines. The Fluent Async Tasks abstraction delivers superpowers over the PPL (Parallel Programming Library) and Future<T>, allowing pipelines based on the Thread Pool:
var CTS := TCancellationTokenSource.Create;
TAsyncTask.Run<TStream>(
function: TStream
begin
// Requests a free Task from the Thread Pool for network download
Result := AsyncClient.DownloadStream('https://api.company.com/data', CTS.Token);
end)
.Then<TReport>(
function(Stream: TStream): TReport
begin
// Chains a new processing Task as soon as the previous one finishes
Result := JsonSerializer.Deserialize<TReport>(Stream);
Stream.Free;
end)
.OnComplete(
procedure(Report: TReport)
begin
// Automatically and safely synchronizes the return with the Original Thread (UI)
ShowReport(Report);
end)
.OnException(
procedure(Ex: Exception)
begin
ShowError('Process failed: ' + Ex.Message);
end)
.Start;
Structured environment for registering services and external configurations using JSON, YAML, or Environment Variables:
var Builder := WebApplication.CreateBuilder;
// Load hierarchical configuration sources
Builder.Configuration
.AddJsonFile('appsettings.json')
.AddYamlFile('config.yaml')
.AddEnvironmentVariables;
Builder.Services
// Natively binds configuration to a strongly-typed class
.Configure<TDatabaseSettings>(Builder.Configuration.GetSection('Database'))
// Complete Dependency Injection for repositories and services
.AddSingleton<IEmailService, TSmtpEmailService>
.AddScoped<IOrderRepository, TDbOrderRepository>;
var App := Builder.Build;
The TEntityDataSet converts the ORM's object orientation (POCOs) into DataSet-compatible structures consumable by your VCL grids, data-aware components, and Design Time reports, without losing performance!
Design-Time Support: Native TFields creation from entity code and record visualization directly in the IDE.
Many frameworks only focus on simple CRUD solutions. Dext was engineered for complex, high-scale enterprise architectures. Take a look at advanced features that show the real power of our infrastructure:
Generate a complete REST CRUD API directly from your domain entities with support for pagination, sorting, granular security, and OpenAPI/Swagger with just a single attribute:
[Table, DataApi('/api/products')]
TProduct = class
private
FId: IntType;
[Required, MaxLength(100)]
FName: StringType;
FPrice: CurrencyType;
public
[PK, AutoInc]
property Id: IntType read FId write FId;
property Name: StringType read FName write FName;
property Price: CurrencyType read FPrice write FPrice;
end;
// Granular security configuration and initialization in a single line:
App.MapDataApis.Configure<TProduct>(
DataApiOptions.RequireAuth.RequireWriteRole(['admin'])
);
Dext is the first framework on the planet with native and integrated support for the Model Context Protocol (MCP). Expose your enterprise system's logic and queries directly as tools for AI Agents (like Claude, Cursor, or Antigravity) to consume securely:
type
[MCPTool('search_products', 'Search active products with price filters')]
[MCPParam('query', 'Product search query term')]
[MCPParam('maxPrice', 'Optional maximum price filter')]
TSearchProductsTool = class
public
function Execute(const AQuery: string; AMaxPrice: Currency): TList<TProduct>;
end;
Develop projects following Clean Architecture patterns, ensuring high decoupling and testability without losing the visual productivity of traditional RAD:
To prove that modernization does not break the classic visual productivity of Delphi RAD, Dext integrates natively into the IDE ecosystem. Here is a step-by-step interactive walkthrough showing how to go from a physical database to live data in your form in seconds:
Say goodbye to manual mapping. Right-click on the form and access the integrated generation tool:
Select which tables from your physical database you want to bring into your domain model:
Dext generates clean, elegant, strongly-typed Object Pascal units decorated with smart attributes:
Connect the TEntityDataProvider to your database. Dext scans your executable via RTTI and dynamically maps entity classes directly inside the IDE's Object Inspector:
Connect the TEntityDataSet to the provider, set the target class, and mark Active = True. Your DBGrid populates instantly with real database records without needing to run the application:
Forget about manual parameter binding and manual SQL queries to run procedures. Dext manages complex procedures as strongly-typed, compile-time verified command objects:
type
[StoredProcedure('ProcessFiscalNotes')]
TProcessNotesCommand = class
private
FStartDate: TDateTime;
FProcessedCount: Integer;
public
[DbParam('StartDate')]
property StartDate: TDateTime read FStartDate write FStartDate;
[DbParam('ProcessedCount', pdOutput)]
property ProcessedCount: Integer read FProcessedCount write FProcessedCount;
end;
Forget about configuring complex APM infrastructures (like Prometheus and Grafana) for local development. Dext includes a built-in Visual Telemetry Dashboard running natively and asynchronously.
It collects (with zero thread impact and no blocking allocations) structured logs, complete physical SQL query profiling, HTTP response times, and detailed Gantt spans for ultra-fast debugging of network and database bottlenecks:
Monitor throughput (RPS), average latency, CPU/Memory consumption, active DB connections, and system logs in a single unified screen:
Analyze the ORM's internal execution flow in Gantt format, displaying exactly the generated SQL query, injected parameters, and response times of each physical transaction:
Dext is composed of flexible and minimalist modules. You retain full control over the architecture and include only the vital components for your solution:
IList, IDictionary). Dext solves the classic Generic Bloat with Binary Code Folding, significantly reducing huge binaries.TAutoMocker), test coverage, and reporting.See the full features list and Dext modules
The easiest way to install Dext is using TMS Smart Setup. Alternatively, you can install it manually directly in the IDE.
You can install Dext either via the graphical user interface (GUI) or the command line:
cesarliws.dext (Dext Framework), select it, and click Install.tms install cesarliws.dext
[!TIP] Don't have TMS Smart Setup? Download it from the TMS Smart Setup Download Page.
For manual compilation, configuration of environment variables/paths, customization via Dext.inc, and installing the design-time packages directly in the Delphi IDE:
Delphi has historically been chosen for domains that did not tolerate overheads; however, recent frameworks have adopted unrestrained allocation patterns based on developer convenience. Dext returns the performance while maintaining modern ease of use:
strings, causing deadly spikes in the Memory Manager and forced pauses. Dext bypasses classic conversion through Direct-to-JSON streaming, reading entire blocks via immutable memory structures (TSpan).Dext is developed and maintained publicly and provided under the Apache License 2.0. It is fully and unconditionally free (for open-source scenarios or strict enterprise/commercial development). Create billion-dollar software, distribute, or encapsulate at will. No catches.
Dext is driven by the community. Whether you are an enthusiastic user or an infrastructure-focused developer, there are many ways to help:
Check out our Roadmap metrics and steps, and see our Code of Conduct to keep this hub welcoming.
Stop rebuilding foundations and spend energy on your customers' problems. Dext takes care of the rest.
Built with pride for the entire Delphi Ecosystem.
A Jetbrains IDE IntelliJ plugin aimed to provide coding agents the ability to leverage intelliJ's indexing of the codeba
Run Claude Code as an MCP server so any agent can delegate coding tasks to it
@microsoft✓ OfficialBrowser automation using accessibility snapshots instead of screenshots