Skip to content
Cesar Romero

Dext Framework V1 RC2: The Modern Integrated Ecosystem for Delphi

Dext V1 RC2

It has been just over 6 months since I published Dext. Since then, the framework has grown immensely in popularity. I have seen an incredible number of posts, technical discussions, and even videos from developers sharing their experiences with Dext.

This is wonderful! However, with the rapid pace of development and the maturity we have achieved in the current V1 RC2, many of these older materials end up mentioning code snippets that were still experimental, syntaxes that have since been simplified, or features that are now consolidated and far more efficient.

To set a clear baseline and showcase the state of the art of Dext today, I have decided to create a series of practical articles that will be published over the coming weeks. We will review the actual architecture, what is 100% production-ready, and how you can get the absolute most out of Dext.

If you work in the Delphi ecosystem, you have likely heard this phrase: “To build modern systems with advanced dependency injection, fluent ORM, and cutting-edge telemetry, we need to migrate to C#/.NET, Go, or Java.”

The Dext Framework proves otherwise. It is a native, integrated, and ultra-high-performance ecosystem for full-stack Delphi development, combining the best of global engineering patterns and optimizing them directly for the Object Pascal compiler.

🚀 What is the Dext Framework?

Section titled “🚀 What is the Dext Framework?”

Dext is not just a mini-framework or a niche ORM. It is a complete enterprise-grade backend platform. It unites the pillars of modern development under a high-performance architecture, eliminating boilerplate so you can focus strictly on your application’s business rules.

Inspired by the robust design of ASP.NET Core (C#), the simplicity and efficiency of Go, and the structured reactivity of Flutter, Dext runs natively in Delphi, generating ultra-lightweight native binaries without virtual machines (JIT) and without the dreaded cold start of managed serverless environments.

🛠️ Get to Know the Ecosystem Pillars

Section titled “🛠️ Get to Know the Ecosystem Pillars”

1. Minimal APIs with Smart Model Binding

Section titled “1. Minimal APIs with Smart Model Binding”

Writing robust REST endpoints with automatic Dependency Injection (DI) now requires minimal effort:

program MyAPI;


uses Dext.Web;


begin
  var App := WebApplication;


  // Endpoint with native Automatic 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 registered successfully');
    end);


  App.Run(8080);
end.

2. High-Performance ORM and Type-Safe Queries

Section titled “2. High-Performance ORM and Type-Safe Queries”

No more magic strings (FieldByName) or queries that break at runtime. The Dext ORM generates the Abstract Syntax Tree (AST) of your Delphi code, ensuring complete strong typing in your queries and advanced enterprise-grade features:

// Complex query with Eager Loading 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')
  .Include('Items')
  .OrderBy(O.Date.Desc)
  .Take(50)
  .ToList;

  • [DataApi] (Zero-Code API): A single annotation ([DataApi]) automatically exposes a complete set of RESTful CRUD endpoints, supporting 11 filter operators via QueryString (e.g., ?price_gt=100&stock_lt=10).

    You can configure it fluently during application startup:

    App.Builder.MapDataApi<TProduct>('/api/products', DataApiOptions
      .AllowRead
      .RequireAuth
    );

    Or directly on the domain class:

    type
      [DataApi] // Auto-registers as /api/products
      [Table('products')]
      TProduct = class
      private
        FId: Integer;
        FName: string;
        FPrice: Double;
      public
        [PK, AutoInc]
        property Id: Integer read FId write FId;
        property Name: string read FName write FName;
        property Price: Double read FPrice write FPrice;
      end;
    

    // And inside the global configuration pipeline:
    App.MapDataApis;

  • Multi-Mapping (Dapper-Style): Hydration of complex and hierarchical object graphs from a single physical query with Joins, recursively and performantly.

  • Shadow Fields: Manage persisted states (like TenantId or audit timestamps) without polluting your domain classes. Your classes remain clean POCOs, while the ORM handles the dirty work in the background.

3. Active Architecture (Trauma-Free Modernization for Legacy ERPs)

Section titled “3. Active Architecture (Trauma-Free Modernization for Legacy ERPs)”

One of the biggest pain points in the Delphi ecosystem is modernizing massive monoliths (VCL/FMX) based on FireDAC queries tightly coupled to the visual interface.

With Dext’s TEntityDataSet, you implement Clean Architecture (MVVM/DDD) while retaining 100% of RAD’s visual productivity:

  • Design-Time Preview: Connect the dataset visually in the IDE, create static fields (TFields) dynamically, and preview real database data without needing to compile the project.
  • Decoupled Runtime: At runtime, the direct connection to the database disappears, and your screens consume pure lists of rich in-memory entities coming from ViewModels.

4. The Planet’s First Native Delphi MCP (Model Context Protocol) Server!

Section titled “4. The Planet’s First Native Delphi MCP (Model Context Protocol) Server!”

Prepare your systems for the artificial intelligence era. Dext introduces built-in support for Anthropic’s MCP protocol. You can expose your business logic and queries directly as secure tools for AI agents (like Claude, Cursor, or Antigravity) to execute and interact with in real time.

🐾 Meet the Official Dext Mascot!

Section titled “🐾 Meet the Official Dext Mascot!”

To accompany the evolution and maturity of V1 RC2, Dext now has a strong visual identity. We present the ecosystem’s official mascot: a high-tech feline designed to reflect the core values of Speed, Lightness, Intelligence, and Reliability that define the framework!

Dext Mascot

Inspired by the cats Nala and Lana, our mascot combines the aerodynamic silhouette of an Oriental Shorthair with a modern cyberpunk aesthetic. Featuring vibrant blue fur and a smart collar proudly sporting the Dext medal, he represents the developer’s ideal companion on the quest for high performance.

📊 Born for Brutal Performance: Zero-Allocation Pipeline

Section titled “📊 Born for Brutal Performance: Zero-Allocation Pipeline”

Typical web components instantiate and process gigabytes of temporary strings to render JSON, causing massive spikes in the Memory Manager.

Dext bypasses classical conversion by utilizing TUtf8JsonWriter with Direct-to-JSON streaming. Data is written continuously from the database to the network socket using immutable memory structures (TSpan), resulting in near-zero memory allocation and brutal throughput.

Additionally, the framework features a native Asynchronous Visual Telemetry Dashboard, gathering full profiling of SQL queries, HTTP latencies, and execution Gantt spans with zero thread impact.

📚 Complete Documentation and Structure

Section titled “📚 Complete Documentation and Structure”

If you wish to dive deeper into every technical detail and understand how the ecosystem was designed:

⚙️ How to Install (Don’t skip this step!)

Section titled “⚙️ How to Install (Don’t skip this step!)”

A very common detail when new developers arrive at Dext is simply downloading the repository or cloning the project via Git and forgetting to read the basic setup instructions, which can lead to trivial path or compilation issues.

To ensure you set up the environment successfully on your first try, follow our detailed and clean installation walkthrough according to your language of choice:

🤝 100% Open Source (Apache 2.0)

Section titled “🤝 100% Open Source (Apache 2.0)”

The Dext Framework is free for personal, academic, or large-scale commercial development. Build billion-dollar software, distribute, modify, and embed without hidden catches.

The project is currently in its Release Candidate 2 (V1 RC2) phase, mature and ready to revolutionize how we build software in Delphi.

👉 Visit the official repository on GitHub, leave your star (⭐) to support the project, and check out the new guides and DDD examples: github.com/cesarliws/dext