🇧🇷 Português

Dext Framework

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.

Delphi Modernization & .NET Parity

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 vs .NET Architectural Narrative — How Dext bridges the backend gap with native compilation.
• Feature-by-Feature Parity Matrix — Over 60+ features compared directly between ASP.NET/EF Core and Dext.
• Complete ORM Capabilities Reference — DbContext, Change Tracking, JSON columns, and Lazy/Eager strategies.
• Enterprise Licensing Guide — Why Dext is completely free, secure, and ready for commercial use under Apache 2.0.

Where to Use?

Dext was specifically designed to solve the real-world pain points faced by Delphi developers:

• Web Applications: Develop complete web applications with Server-Side rendering using WebStencils or native templates integrated into the pipeline.
• High-Performance APIs: Build robust RESTful backends using Minimal APIs, Controllers, or generating direct endpoints with the [DataApi] attribute.
• Concurrency and Asynchrony: Use Dext Threading (Async Task, Cancellation Token, Async Rest Client) to create background routines and non-blocking workflows, replacing the complex manual usage of the TThread class.
• Mobile Backend (iOS/Android): Provide the integration, connectivity, and security infrastructure needed to support mobile applications efficiently.
• Legacy Modernization: Gradually integrate with old 3-tier systems (like DataSnap), ISAPI/Apache middlewares, or Desktop monoliths (VCL) without having to rewrite your 20-year-old ERP. Dext acts as a modern foundation within existing systems.
• Background Services and Microservices: Robust data extraction, high-performance scheduled tasks, and connectivity between applications.

Quick Start

See how Dext's structure simplifies complex flows into clean, typed, and object-oriented code. Exploring the framework's pillars:

Minimal API

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.

Simple Entity (COC, DataApi, and Smart Properties)

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;

ORM and Strongly Typed Queries (Type-Safe)

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;

Async Processing (Fluent Tasks)

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;

Configuration, Options & DI

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;

Full VCL Compatibility (TEntityDataSet)

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.

⚡ Enterprise-Grade Power: Dext Goes Far Beyond the Basics

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:

1. Database as API (REST CRUD Zero-Code)

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'])
);

2. Native MCP Server (Your Delphi App Ready for AIs)

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;

3. Clean Architecture & Design-Time VCL

Develop projects following Clean Architecture patterns, ensuring high decoupling and testability without losing the visual productivity of traditional RAD:

• Design-Time Preview: Connect the dataset visually inside the IDE, create static fields (TFields) dynamically, and preview live database records inside the IDE without having to compile the project.
• Real Decoupling: Remove direct database connections and SQL queries scattered across your UI screens, keeping your presentation layer