If you've opened a Delphi visual designer on a 4K laptop or a high-resolution external monitor, you know the feeling: blurry icons, toolbar buttons that are too small to read, controls that land in the wrong place when you drop them on a form. Embedding a scripting IDE into your own application means inheriting all of those problems — and exposing them to your end users.

TMS Scripter is a scripting engine for Delphi applications. It lets you add a full Pascal or Basic scripting language to your software, complete with an embeddable IDE: a code editor with syntax highlighting and code completion, a visual form designer, an object inspector, and a debugger. Because that IDE runs inside your application, the way it renders on modern displays is the way your users experience it.

TMS Scripter 8.0 is, above all, about making that experience crisp. This release brings full High DPI support throughout the Scripter IDE and the visual scripter components, alongside a new platform target, a reorganized documentation set, and a more modern codebase. Let's walk through what changed.

Sharp on High DPI displays

High DPI support is the headline of this release. On a standard 96-DPI monitor everything looked fine; the trouble started at 150%, 200%, and beyond — exactly the scaling factors most modern laptops and 4K screens use by default. Version 8.0 addresses this across the board.

Modern, scalable icons. Every icon in the Scripter IDE — the toolbar, the menus, and the component palette — has been redrawn as a modern, High DPI-aware set. The object inspector's own glyphs (expand/collapse, the drop-down and dialog buttons, the spin buttons) were updated too, so they render correctly instead of as tiny smudges on a scaled display.

A form designer that behaves at any scale. The visual designer received the bulk of the fixes:

• Controls now drop where you put them. Previously, inserting a control by clicking or dragging on the form designer placed it at roughly twice the intended position and size on a scaled monitor. That double-scaling bug is gone — what you draw is what you get.
• The grid and snap-to-grid respect DPI. Grid spacing, grab-handle size, and the arrow-key move/resize step are now treated as logical (96-DPI) values and scaled to the physical display. The grid stays visually consistent at any scaling factor, and the grid dots remain visible on High DPI screens.
• Grab handles resize correctly when you move a form between monitors with different DPI settings.
• Non-visual components and the component palette render at the right size. Both now load the High DPI (32px) icon variants when available, with a clean fallback to the standard icons.

The little things, too. The IDE splitter now starts at a sensible position on High DPI monitors, several dialogs that weren't being centered on screen now are, and the splitter-drag cursor shows up in the correct spot even when the host application is marked DPI-unaware while running on a High DPI monitor.

A new platform: WinArm64EC

TMS Scripter 8.0 adds support for the WinArm64EC platform introduced in Delphi 13.1. ARM64EC ("Emulation Compatible") is Microsoft's ABI for building native ARM64 apps on Windows that can interoperate with existing x64 code in the same process. If you're targeting Windows on ARM, you can now ship scripting capabilities there too.

Documentation, reorganized around how you actually use Scripter

The user guide has been rewritten and split by audience into three clear chapters:

• Working with Scripter — running, executing, and debugging scripts.
• Extending Scripter — integrating the engine with your host application: registering classes, methods, properties, functions, and libraries. This is now presented RTTI-first, matching the recommended modern approach.
• Writing Scripts — the supported Pascal and Basic languages, plus declaring forms and classes from within a script.

The content is cross-linked to the API Reference, outdated version-specific notes have been removed, and the modern TatScripter / TIDEScripter components and the RTTI-based registration approach are presented as the default throughout. If you've been learning Scripter from older docs, this is a good moment to revisit them.

A more modern codebase under the hood

To move faster and write cleaner code, TMS Scripter 8.0 drops support for Delphi 7, 2009, 2010, and XE — the minimum is now Delphi XE2. This unlocks generics, anonymous methods, and the modern System.Rtti unit, all of which were impossible to rely on while maintaining compatibility with a 2002-era compiler.

If you're still on one of those versions, you're not stuck: version 7.36 (the last release to support them) remains available for download via TMS Smart Setup, which automatically detects your Delphi version and installs the last compatible release.

We covered the reasoning, the trade-offs, and what it means for the codebase in a dedicated post — Dropping Delphi 7 support in TMS Scripter — if you'd like the full story.

Developer-facing improvements

A few changes target you, the developer integrating Scripter into your application.

Generic array parameters in RTTI registration. When you register a class with DefineClassByRTTI, methods that take a generic array parameter — for example TArray<string> — are now handled correctly. Previously such methods needed manual workarounds; now they just work.

type
  TReportService = class
  public
    // A method that takes a generic array parameter
    procedure Generate(const Sections: TArray<string>);
  end;

procedure TReportService.Generate(const Sections: TArray<string>);
var
  I: Integer;
begin
  for I := Low(Sections) to High(Sections) do
    WriteLn('Building section: ' + Sections[I]);
end;

// In your host application, register the class via RTTI:
Scripter.DefineClassByRTTI(TReportService);

Once registered, the script can call the method naturally, passing an array straight through:

var
  Service: TReportService;
  Sections: array[0..2];
begin
  Sections[0] := 'Summary';
  Sections[1] := 'Details';
  Sections[2] := 'Appendix';

  Service := TReportService.Create;
  try
    Service.Generate(Sections);
  finally
    Service.Free;
  end;
end;

Import tool supports Delphi 12 and 13. You can now import library units from the latest two IDE versions, so wrapping your own units and third-party libraries for use in scripts stays in step with your Delphi installation.

More bookmarks in the editor. The code editor's TIDEMemo.BookMarkMax property lets you raise the bookmark limit beyond the previous fixed maximum (the default remains 10).

Alongside these, the release fixes a long-standing annoyance: cursor and selection position in the code editor are now correctly preserved when switching between files or saving.

Getting it

TMS Scripter 8.0 is available now on the product page. If you're already a customer, install it via TMS Smart Setup; the modern, High DPI-aware IDE is what your users will see the moment you rebuild.

For anyone who adds scripting to their Delphi applications, 8.0 removes a class of papercuts that mattered most on exactly the hardware your users run today — and lays a more modern foundation for what comes next.

• TMS Scripter product page
• TMS Scripter documentation
• What's new in 8.0
• Dropping Delphi 7 support — the reasoning

Three Ways to Customize Cell Appearance

function TForm2.WebDBDataGrid1Column_HpGetCellStyle(
  Params: TJSCellClassParams): TJSValue;
begin
  if Integer(Params.Value) > 500 then
    Result := new(['color', 'red',
                   'backgroundColor', 'yellow']);
end;

function TForm2.WebDBDataGrid1Column_HpGetCellClass(
  Params: TJSCellClassParams): TJSValue;
begin
  if Integer(Params.Value) > 500 then
    Result := 'supercar';
end;

.supercar {
  color: red;
  background-color: yellow;
}

function TForm2.WebDBDataGrid1Column_PriceValueFormatter(
  Value: TJSValue): TJSValue;
var
  i: Integer;
begin
  i := Integer(Value);
  Result := FormatFloat('#,##0', i) + '€';
end;

Combining Formatting and Styling

function TForm2.WebDBDataGrid1Column_PriceGetCellStyle(
  Params: TJSCellClassParams): TJSValue;
begin
  Result := new(['text-align', 'right']);
end;

With a couple of simple lines of code, we get the presentation of the data from this stale appearance:

Loading Data Dynamically

procedure TForm2.WebFormShow(Sender: TObject);
begin
  WebClientConnection1.URI :=
    'https://download.tmssoftware.com/tmsweb/demos/TMSWEB_ResponsiveGrid/carsfull.json';

  WebClientConnection1.Active := True;
end;

Conclusion

• OnGetCellStyle for dynamically generated inline styles
• OnGetCellClass for CSS-based styling
• ValueFormatter for custom value presentation

Try it today

The installer for TMS VCL UI Pack is getting a major upgrade. Both the trial and the registered editions are moving to a new installation flow — faster to set up, easier to keep updated, and ready for the latest RAD Studio target platforms.

A modern installer experience

The new installers make setup more consistent and easier to use, whether you are evaluating TMS VCL UI Pack with the trial version or installing the registered version as an existing customer.

The migration also updates the underlying installer technology to cover the latest RAD Studio target platforms, including Windows on Arm (Arm64EC). 

Installing TMS VCL UI Pack

Registered version (via TMS Smart Setup)

The registered version of TMS VCL UI Pack will be available exclusively through TMS Smart Setup. Before installing please uninstall the classic installation via the control panel.

If you are new to TMS Smart Setup, see the Smart Setup documentation to install the tms command-line tool. Once it is set up, install TMS VCL UI Pack with:

tms install tms.vcl.uipack

Prefer a visual workflow? You can also install the product through TMS Dashboard, a central hub for managing TMS component installations and updates.

Trial version

Evaluating TMS VCL UI Pack? Download the trial from the TMS VCL UI Pack product page: click Free Trial, enter your email address, and choose your IDE. The trial downloads instantly, and you'll receive a trial key which can be entered during setup. 

Moving forward

With this migration, TMS VCL UI Pack gains a cleaner installation experience, tighter alignment with TMS Smart Setup, and better support for today's multi-platform Delphi & C++Builder development workflows.

This is part of a broader move across the entire TMS product portfolio. After TMS VCL UI Pack, the next product family planned for the modernized installer flow is the TMS FNC family.

As always, we welcome your feedback. Try the new way of installing TMS VCL UI Pack and let us know how we can keep improving the setup experience.

• GPX route visualization
• Free OpenStreetMap integration
• JPEG photos with embedded GPS EXIF data
• Interactive map markers with image previews

The Result

The application loads:

• GPX routes on top of a free OpenStreetMap layer
• Photos with GPS metadata
• Interactive image markers directly on the map

A typical result looks like this:

The Main Ingredients

The application is intentionally compact and easy to understand.

The core technologies used are:

procedure TMapAlbumForm.TMSFNCMaps1MapInitialized(Sender: TObject);
begin
  btnAddPhotos.Enabled := true;
  btnAddRoutes.Enabled := true;
  btnClear.Enabled := true;
end;

procedure TMapAlbumForm.btnAddRoutesClick(Sender: TObject);
begin
  if openRoute.Execute then
  begin
    TMSFNCMaps1.LoadGPXFromFile(openRoute.FileName, true, true, 3, clrPanel.Color);
  end;
end;

img := TAdvCloudExifImage.Create(MapAlbumForm);

try
  img.AutoLoad := false;
  img.FileName := fname;
  img.LoadData;

  if img.HasGPSData then
  begin
    lon := img.Longitude;
    lat := img.Latitude;
  end;
finally
  img.Free;
end;

m := Map.AddMarker(lat,lon);
m.IconURL := JpegToBase64(fname, 240);

'data:image/jpeg;base64,' +
TNetEncoding.Base64.EncodeBytesToString(
  OutStream.Memory,
  OutStream.Size
);

TMSFNCMaps1.ZoomToBounds(Coords.NorthEast, Coords.SouthWest);

TMS Scripter 8.0 — the scripting engine that lets Delphi applications execute Pascal and Basic scripts at runtime — is coming soon, and it will be the first release to require Delphi XE2 or later. Delphi 7, Delphi 2007, Delphi 2010, and Delphi XE are no longer in the supported range.

TMS Diagram Studio, TMS Workflow Studio, and TMS Query Studio will make the same change in their own upcoming releases.

A Long-Running Commitment

TMS Scripter has supported Delphi 7 since day one — the library was born in that era, and the compatibility was maintained for roughly twenty-five years. Many TMS customers run production applications on legacy Delphi versions that cannot be easily migrated, and keeping them supported was always a deliberate choice.

But that chapter is now closed. The time has come to move forward.

Why We Are Dropping Support

Delphi 7 predates two of the most important additions to the Object Pascal language: generics and anonymous methods, both introduced in Delphi 2009. Every line of code in TMS Scripter had to be written as if those features did not exist, which created real and lasting constraints:

• Untyped collections everywhere. Without generics, lists of objects use untyped TList with manual typecasts at every access site. Code that would naturally be TList<TScript> must instead work with raw pointers and explicit casts throughout.
• Callback boilerplate. Registering Delphi methods for use in scripts requires separate named wrapper procedures for each one. Anonymous methods would allow the logic to be co-located with its registration, but that was not an option.
• No advanced RTTI. The System.Rtti unit — which allows full runtime inspection of classes, methods, properties, and their types — arrived in Delphi 2010. It is unavailable on Delphi 7 entirely, which means a scripting engine cannot use it to automatically discover and register Delphi classes. Everything has to be done manually.
• API surface limited by the lowest common denominator. Public APIs that would benefit from typed generics or procedure references had to fall back to TObject, Pointer, or method-of-object types.

This is not a criticism of Delphi 7. It had its time, and it served its users well. But maintaining compatibility with a compiler from 2002 while trying to build a modern, maintainable library is a genuine tension, and it has accumulated over the years.

What This Opens Up

TMS Scripter 8.0 itself does not yet take full advantage of the new baseline — this is the first step, not the finished product. We want to see how the community reacts before committing to deeper API changes.

What the change does is remove a hard constraint. Going forward, the codebase can evolve toward:

Generics. Internal collections can become properly typed. TList<T> instead of TList. Fewer typecasts, stronger compile-time checks, better IDE code completion.

Advanced RTTI. The System.Rtti unit gives a program full runtime knowledge of any class — its methods, parameters, return types, properties, and attributes. For a scripting engine, this is particularly powerful: instead of manually writing a wrapper procedure for every method you want to expose to scripts, the engine can potentially walk the RTTI of a class and register everything automatically. This is the kind of capability that can dramatically reduce the boilerplate burden on users and make Scripter integration with arbitrary Delphi classes much more seamless.

Anonymous methods. Callback types can be changed from method-of-object references to reference to procedure. To illustrate the kind of improvement this enables — today, registering a Delphi class method for use in a script looks like this:

// Current approach: a dedicated class with one wrapper method per Delphi method
type
  TMyLibrary = class(TatScripterLibrary)
  protected
    procedure CalculateProc(AMachine: TatVirtualMachine);
    procedure Init; override;
  end;

procedure TMyLibrary.Init;
begin
  with Scripter.AddDelphiClass(TMyCalculator) do
    DefineMethod('Calculate', 1, tkInteger, nil, CalculateProc);
end;

procedure TMyLibrary.CalculateProc(AMachine: TatVirtualMachine);
begin
  with AMachine do
    ReturnOutputArg(TMyCalculator(CurrentObject).Calculate(GetInputArgAsInteger(0)));
end;

Once the callback type supports procedure references, the same registration can be written inline:

// Future direction: registration and implementation in one place
with Scripter.AddDelphiClass(TMyCalculator) do
  DefineMethod('Calculate', 1, tkInteger, nil,
    procedure(AMachine: TatVirtualMachine)
    begin
      AMachine.ReturnOutputArg(
        TMyCalculator(AMachine.CurrentObject).Calculate(
          AMachine.GetInputArgAsInteger(0)));
    end);

None of this was possible while the library had to compile on Delphi 7. Now it is.

You Are Not Stranded: TMS Smart Setup Versioning

If you are still on Delphi 7, or on one of the other versions now leaving the support window, you are not left without options.

TMS Smart Setup — the TMS Software installer and package manager — includes a versioned installation feature designed exactly for this situation. When you use Smart Setup to install TMS Scripter, it detects which Delphi version you have and serves you the last release that supports it — automatically, without you having to track which archive corresponds to which compiler.

The end of active compatibility maintenance does not mean the last supported version disappears.

What About the Other Products?

TMS Scripter gets the headline, but it is not the only product affected.

TMS Diagram Studio — the framework for building diagram and flowchart editors in Delphi VCL applications — will drop the same set of legacy versions in an upcoming release.

TMS Workflow Studio — a workflow engine for defining and executing business processes within Delphi applications — follows the same path.

TMS Query Studio — the visual query builder component for building complex queries at runtime — likewise.

All four products share the same compatibility floor going forward: Delphi XE2 or later.

What This Means for You

If you are on Delphi XE2 or later: you are in the supported range. TMS Scripter 8.0 will install and work as usual when it releases.

If you are on Delphi 7, 2007, 2010, or XE: the last version of each product that supported your compiler remains fully functional. Use Smart Setup to install it cleanly — it will continue to work exactly as it always has.

Links

• TMS Scripter product page
• TMS Scripter documentation
• TMS Smart Setup
• Smart Setup version compatibility guide

Introduction

• Editing cells
• Sorting columns
• Filtering columns
• Paging through records

Editing Data with Built-in Cell Editors

Sorting Columns

procedure TForm1.btnSortSortableColumnClick(Sender: TObject);
var
  SO: TDGSortOrder;
begin
  case cmbSortOrder.ItemIndex of
    0: SO := TDGSortOrder.soAscending;
    1: SO := TDGSortOrder.soDescending;
    else SO := TDGSortOrder.soNone;
  end;

  WebDataGrid1.ColumnDefs.FindColumn('SortableColumn').Sort(
    SO,
    chkAddToExistingSortOrder.Checked);
end;

procedure TForm1.btnClearSortingClick(Sender: TObject);
begin
  WebDataGrid1.ColumnDefs.ClearSorting;
end;

Filtering Columns

procedure TForm1.WebFormCreate(Sender: TObject);
var
  Data, IStr, IStr2: String;
  I: Integer;
begin
  WebDataGrid1.ColumnDefs[1].Filter := True;
  WebDataGrid1.ColumnDefs[2].Filter := True;

  Data := '';
  for I := 1 to 50 do
  begin
    IStr := IntToStr(I);
    IStr2 := IntToStr(Random(100));
    Data := Data + IStr + ',"Item #' + IStr + '", ' + IStr2 + #$D#$A;
  end;

  WebDataGrid1.LoadFromCSVString(Data);
end;

procedure TForm1.btnFilterTextColumnClick(Sender: TObject);
begin
  WebDataGrid1.ColumnDefs.FindColumn('TextColumn').ApplyFilter(
    TDGFilterType.gftText,
    TDGFilterOperation.foContains,
    '#1');
end;

procedure TForm1.btnFilterNumberColumnClick(Sender: TObject);
begin
  WebDataGrid1.ColumnDefs.FindColumn('NumberColumn').ApplyFilter(
    TDGFilterType.gftNumber,
    TDGFilterOperation.foGreaterThanOrEqual,
    25);
end;

procedure TForm1.btnClearFiltersClick(Sender: TObject);
begin
  WebDataGrid1.ColumnDefs.ClearFilters;
end;

procedure TForm1.btnClearTextColumnClick(Sender: TObject);
begin
  WebDataGrid1.ColumnDefs.FindColumn('TextColumn').ClearFilter;
end;

procedure TForm1.btnClearNumberColumnClick(Sender: TObject);
begin
  WebDataGrid1.ColumnDefs.FindColumn('NumberColumn').ClearFilter;
end;

Pagination

procedure TForm1.WebFormCreate(Sender: TObject);
var
  Data, IStr: String;
  I: Integer;
begin
  Data := '';
  for I := 1 to 300 do
  begin
    IStr := IntToStr(I);
    Data := Data + IStr + ',"Item #' + IStr + '","Item #' + IStr + '"' + #$D#$A;
  end;

  WebDataGrid1.LoadFromCSVString(Data);
  UpdatePagination;
end;

procedure TForm1.UpdatePagination;
begin
  WebDataGrid1.Pagination := true;
  WebDataGrid1.PaginationPageSizeSelector := '20,40,80';
  WebDataGrid1.PaginationPageSize := 40;
end;

Combining the Features

• Editable columns for quick data entry
• Sorting for comparing records
• Filtering for narrowing down large lists
• Pagination for keeping the UI fast and readable

Conclusion

TMS FNC Cloud Pack is well known for its ready-made components to services like Google Drive, Microsoft Outlook Mail. What is often overlooked is that the same package also gives you a lightweight, asynchronous HTTP engine called TTMSFNCCloudBase. With just a few lines of code, this engine lets you talk to any REST API, even when there is no pre-built wrapper available.

In this blog post we will show how easy this is by building a working currency converter from scratch in a short time. Thanks to the FNC framework, the same code runs on VCL, FMX, and TMS WEB Core.

Picking an API

If you are looking for a free API to experiment with, Free Public APIs is a handy curated directory. For this example we picked UniRateAPI, a currency rate service with a generous free tier and a clean REST interface.

Create a free account at unirateapi.com and copy your API key from the dashboard. One detail to keep in mind right away: the API requires a User-Agent header on every request and will return HTTP 403 if it is missing. We will come back to this in step 3.

The Building Block: TTMSFNCCloudBase

For APIs that authenticate with a simple key (rather than OAuth 2.0), TTMSFNCCloudBase is all you need. The workflow is the same every time. You create an instance, populate its Request object with the host, path, query, headers, and HTTP method, and then call ExecuteRequest with a callback procedure. The call returns immediately and the response arrives on the callback, which keeps the UI fully responsive.

Step-by-Step Implementation

1. Create the instance

procedure TForm1.FormCreate(Sender: TObject);
begin
  FCloudService := TTMSFNCCloudBase.Create;
end;

No setup is needed at construction time. The same instance can be reused for any number of subsequent requests.

2. Build the request

The conversion endpoint is GET /api/rates on https://api.unirateapi.com. The required query parameters are api_key, amount, from, to, and format.

FCloudService.Request.Clear;
FCloudService.Request.Name   := 'GET CURRENCY CONVERT';
FCloudService.Request.Host   := 'https://api.unirateapi.com';
FCloudService.Request.Path   := '/api/rates';
FCloudService.Request.Query  := 'api_key='  + TTMSFNCUtils.URLEncode(edAPIKey.Text)
                               + '&amount=' + edAmount.Text
                               + '&from='   + edFrom.Text
                               + '&to='     + edTo.Text
                               + '&format=json';
FCloudService.Request.Method := rmGET;

TTMSFNCUtils.URLEncode (from TMS FNC Core) safely escapes any special characters in the API key.

3. Add the required User-Agent header

As mentioned earlier, UniRateAPI will reject requests without a User-Agent header. Adding one takes a single line:

FCloudService.Request.AddHeader('User-Agent', 'TMSFNCCloudAPIWrapper');

AddHeader can be called repeatedly to attach any number of custom headers. This is useful whenever an API requires bearer tokens, header-based API keys, or vendor-specific values.

4. Execute asynchronously

FCloudService.ExecuteRequest(DoAPIRequestResult);

The call is non-blocking. The UI thread stays free while the HTTP round-trip completes in the background.

5. Handle the response

The callback receives a TTMSFNCCloudBaseRequestResult record that carries the HTTP status code and the raw response body. When the request succeeds, the JSON payload is parsed with TJSONObject.ParseJSONValue, and the relevant numeric values are extracted and assigned to the TLabel controls on the form so the user sees the converted amount and the exchange rate. The JSON object is freed in a try..finally block to avoid memory leaks.

procedure TForm1.DoAPIRequestResult(
  const ARequestResult: TTMSFNCCloudBaseRequestResult);
var
  LJson: TJSONObject;
begin
  if ARequestResult.ResponseCode = 200 then
  begin
    LJson := TJSONObject.ParseJSONValue(ARequestResult.ResultString) as TJSONObject;
    if Assigned(LJson) then
    try
      lbToAmount.Text := FormatFloat('0.00',
        (LJson.GetValue('result') as TJSONNumber).AsDouble);
      lbRate.Text := FormatFloat('0.00',
        (LJson.GetValue('rate') as TJSONNumber).AsDouble);
    finally
      LJson.Free;
    end;
  end;
end;

A successful response looks like this:

{
  "base": "USD",
  "target": "EUR",
  "rate": 0.9187,
  "amount": 100,
  "result": 91.87
}

The result field holds the converted amount and is assigned to lbToAmount, while the rate field holds the exchange rate used and is assigned to lbRate. Both values pass through FormatFloat with the '0.00' mask so they always display with two decimal places. 

6. Clean up

procedure TForm1.FormDestroy(Sender: TObject);
begin
  FCloudService.Free;
end;

Download the complete sample project shown in this post.

Conclusion

With a handful of lines of Delphi code, TMS FNC Cloud Pack gives you access to any REST API. The same TTMSFNCCloudBase class that powers the built-in Google Drive, Microsoft Outlook Mail wrappers is available to you for any service you want to integrate, whether public or in-house. And when an API uses OAuth 2.0 instead of a static key, TTMSFNCCloudOAuth picks up where this example leaves off and handles the full three-step authentication flow for you. 

After more than two decades of life as a closed-source product, the full source code of TMS Data Modeler is now publicly available on GitHub:

github.com/tmssoftware/datamodeler

This post is a quick tour of what the release means, what's in the repo, and why opening it up took more than just flipping a switch. 

Don't forget to start the repository!

A quick refresher on TMS Data Modeler

TMS Data Modeler is a visual database design tool for Windows, written in Delphi.

In a nutshell, it lets you:

• Design databases visually with entity-relationship diagrams
• Generate DDL scripts to create databases
• Generate ALTER scripts to update existing databases between versions
• Reverse-engineer existing databases
• Compare versions and projects
• Archive history and validate models
• Convert models between different database systems

Supported databases: SQL Server, Firebird, Oracle, PostgreSQL, MySQL, and SQLite.

And for TMS Aurelius users — the ORM framework for Delphi — Data Modeler is the most natural way to work in a database-first style: model your schema visually, then generate the Aurelius entity-mapped classes directly from the model.

A bit of history

Data Modeler has been around far longer than its current name suggests:

• Late 1990s / early 2000s — originally developed by a Brazilian company as an internal tool. It wasn't even primarily a modeling tool back then: it was a CRUD form generator, and the database modeling part existed only to feed metadata into the form generation.
• Mid 2000s — acquired by Devgems and rebranded as DevGems Data Modeler.
• Later — acquired by TMS Software and re-released as TMS Data Modeler.

More than twenty years of evolution land in the repository you can now git clone.

Why we're releasing the source

Several motivations led to opening up the source:

• Transparency — customers can read, audit, and trust the code they rely on.
• Flexibility — teams can adapt the tool to specific needs that wouldn't make sense as features in the mainstream product.
• Community contributions — pull requests are welcome, and improvements from the community flow back to all users.
• Ecosystem alignment — it brings Data Modeler in line with the rest of the TMS BIZ products, where source access is the norm.
• Learning — both as a way to understand Data Modeler internals, and as a real-world example of a non-trivial Delphi application built on top of TMS components.

That last point deserves its own section.

A real-world example of TMS components in action

If you've ever wanted to see how TMS components fit together in a serious, production-grade Delphi application, the repository is a good place to read code. Among other things, Data Modeler uses:

• TMS Diagram Studio — powers the entity-relationship diagram editor: the canvas, shapes, connectors, and the whole visual editing experience.
• TMS Scripter — the entire scripting extensibility layer. Users can write scripts that automate tasks against the model, and that fully customize the class-generation output.
• TMS Aurelius — used specifically in the export / code-generation task, to reuse types declared in Aurelius units when emitting entity classes. (Data Modeler does not use Aurelius as its own persistence layer.)
• TMS VCL UI Pack — the entire desktop UI: ribbon, menus, edits, grid, and the rest of the controls that make up the application's look and feel.

Plus a non-TMS dependency: JAM Software Virtual TreeView.

For a Delphi developer evaluating these components, reading how they're wired up in a real product is often more useful than any tutorial.

What it took to get here

Releasing the source of a closed-source product is not just flipping a visibility flag. A closed-source codebase grows under the assumption that nobody else will ever read it — and that assumption shows up in lots of small places.

To get Data Modeler ready for the public, we did a substantial pass over the code:

• Reviewed and sanitized the entire codebase
• Reorganized units into category folders — Model, Connectors, Dialogs, and others. Before the cleanup, every unit lived flat in a single folder
• Broke remaining circular unit references so the structure makes sense as you navigate it
• Translated remaining Portuguese comments and identifiers (leftovers from the tool's origins)
• Removed several third-party dependencies, both to reduce licensing surface and to make ongoing upgrades to newer Delphi versions easier
• Removed the internal license-control machinery — no longer meaningful with the source in the open
• Rebuilt the full CI/CD deployment pipeline

One deliberate non-decision: we did not rename units to follow a stricter naming convention. The folder structure already conveys scope, and renaming hundreds of units would be a lot of churn for very little gain. Over time, individual units may get renamed as we revisit them, but no top-down rename was warranted.

Given all the effort above, this new milestone of source code availability, the removal/refactor of several parts of application (no more licensing tool, splash screen removed, automatic updates disabled, among others), we updated the version number and the current available source code, binary and installers are now released as TMS Data Modeler 4.0

Built with TMS Smart Setup

The repository is fully prepared for TMS Smart Setup, which gives you two convenient flows.

Build from the command line — from the repository root, run:

tms restore tms.snapshot.yaml -skip-register

Smart Setup resolves all third-party dependencies and builds the dm.exe binary.

Set up for development in the IDE — running tms restore from an existing valid Smart Setup folder installs the required components into the IDE, so you can open dm/dm.dproj in Delphi 13 to build, debug, and explore the code interactively.

For end users who simply want to install the tool, the new CI/CD pipeline publishes installer binaries automatically to the GitHub Releases page — no source involved.

A note on licensing

TMS Data Modeler is source-available, not open source. In short:

• Non-commercial use (learning, evaluation, education, open-source projects) does not require a paid license
• Commercial use still requires a paid license, available from the product page
• Contributions are accepted under the terms in the repository's LICENSE.txt

Support continues through the TMS Support Center as before.

Where to go from here

• Repository: github.com/tmssoftware/datamodeler. Give a star to it!
• Product page: tmssoftware.com/site/tmsdm.asp
• Documentation: doc.tmssoftware.com/biz/datamodeler

Clone it, build it, explore the code, file a PR — or just keep using the binary releases. The choice is yours, and that's the point.

Intro

Not every data operation belongs on screen. Sometimes you need to load a data set, filter it, sort it, group it, calculate summaries, and export the result without showing a grid at all.

That is where the headless data layer in TMS FNC Data Grid becomes especially useful. With TTMSFNCDataGridData, the same engine that powers the visual TTMSFNCDataGrid can be used independently in services, background jobs, console tools, tests, batch exports, or startup data preparation routines.

In other words: you can use the grid's data intelligence without needing the grid's visual surface.

Why Use a Headless Data Layer?

A visual grid is perfect when users need to inspect and interact with data. But many application workflows happen before, after, or completely outside the UI:

• Background processing: load data, transform it, and prepare results while the UI remains responsive

• Batch exports: generate filtered CSV files without creating a form or control

• Automated tests: verify sorting, filtering, grouping, and aggregation logic without UI automation

• Services and console apps: reuse familiar grid data operations in non-visual applications

The important part is that TTMSFNCDataGridData owns the data operations. Methods such as Filter.Add, ApplyFilter, Sort, Group, SaveToCSVData, and the typed accessors like Strings[], Floats[], and Ints[] are available directly on the data layer.

Creating the Data Object

Because TTMSFNCDataGridData is a regular Delphi object, it can be created anywhere you would normally create an object. There is no need for a form, parent control, or rendering context.

type
  TMyForm = class(TForm)
  private
    FData: TTMSFNCDataGridData;
  end;

procedure TMyForm.FormCreate(Sender: TObject);
begin
  FData := TTMSFNCDataGridData.Create;
end;

procedure TMyForm.FormDestroy(Sender: TObject);
begin
  FData.Free;
end;

That small setup gives you a reusable in-memory data layer with the same core operations you would expect from the visual grid.

Loading Data

The headless layer supports the same practical loading scenarios as the grid. You can load JSON, load CSV, or fill cells manually when you want full control.

// From JSON
FData.Options.IO.StartRow := 1;
FData.LoadFromJSONData(
  JSONPath,
  '', '',
  ['id', 'name', 'category', 'price', 'stock', 'is_organic', 'is_vegan']);

// From CSV
FData.LoadFromCSVData('products.csv', ',');

Setting Options.IO.StartRow to 1 before loading JSON is a useful detail: row 0 can receive the JSON key names as column headers, while the actual records start below that fixed header row.

Manual population is equally direct:

FData.ColumnCount   := 3;
FData.FixedRowCount := 1;
FData.RowCount      := 4;

FData.Cells[0, 0] := 'ID';
FData.Cells[1, 0] := 'Name';
FData.Cells[2, 0] := 'Price';

FData.Cells[0, 1] := 1;
FData.Cells[1, 1] := 'Widget A';
FData.Cells[2, 1] := 9.99;

Filtering Without a Grid

Filtering works the same way it does with the visual grid. Add one or more filter conditions, apply them, and then work with the displayed rows.

FData.Filter.Clear;
FData.Filter.Add(COL_CATEGORY, gftEqual, 'Meat');
FData.ApplyFilter;

After calling ApplyFilter, rows that do not match are hidden from the active view. You can use IsRowDisplayed when iterating the data:

var Count := 0;

for var R := FData.FixedRowCount to FData.RowCount - 1 do
  if FData.IsRowDisplayed(R) then
    Inc(Count);

Log(Format('%d matching rows', [Count]));

To return to the full data set, call RemoveFilter.

FData.RemoveFilter;

Sorting the Active Result

Sorting is just as compact. The data layer can sort a column in ascending or descending order without requiring any visual repaint cycle.

FData.Sort(COL_PRICE, gsdDescending);

Sorting and filtering work together. When a filter is active, the sort operation reorders the displayed rows while keeping filtered-out rows hidden.

Grouping and Aggregations

The headless layer is also useful when you need summary data. You can group by a column and calculate values such as count, sum, average, minimum, or maximum.

FData.Group(COL_CATEGORY);
FData.GroupCount(COL_CATEGORY);
FData.GroupSum(COL_PRICE);

Once grouped, the result contains group header rows and summary rows that can be inspected programmatically:

for var R := FData.FixedRowCount to FData.RowCount - 1 do
begin
  if FData.IsRowNode(R) then
    Log(FData.Strings[FData.FixedColumnCount, R])
  else if FData.IsRowSummary(R) then
    Log(Format('  count=%.0f   sum=$%.2f',
      [FData.Floats[COL_CATEGORY, R], FData.Floats[COL_PRICE, R]]));
end;

FData.Ungroup;

This makes it convenient to build reporting features where the final output is a log, CSV file, dashboard feed, or another data structure rather than an interactive grid.

Exporting the Result

After loading, filtering, sorting, and grouping, you can export the processed result directly to CSV.

FData.SaveToCSVData('output.csv', ',');

This is a practical pattern for server-side export buttons, scheduled reporting tasks, or command-line tools that need the same data behavior as your application's UI.

Reading Typed Values

When looping over rows, use the typed accessors to keep your code clear and efficient. Instead of reading everything as text and converting manually, read the expected data type directly from the layer.

var Name  := FData.Strings[COL_NAME,  Row];
var Price := FData.Floats [COL_PRICE, Row];
var Stock := FData.Ints   [COL_STOCK, Row];

For tight processing loops, this keeps the intent of the code obvious: names are strings, prices are floating point values, stock counts are integers.

Showing the Data Later

Using the headless layer does not lock you into a non-visual workflow. If the processed data later needs to be shown in a TTMSFNCDataGrid, you can load the same source into the grid or copy values into the visual component.

// Let the grid load its own visual copy
TMSFNCDataGrid1.LoadFromJSONData(
  JSONPath,
  '', '',
  ['id', 'name', 'price']);

For database-backed scenarios, TTMSFNCDataGridDatabaseAdapter can be used with a shared TDataSet. You can bind that adapter to a visual grid, or bind it directly to TTMSFNCDataGridData when the workflow is headless and the data operations matter more than immediate visual interaction.

Binding a Dataset

For a non-visual workflow, assign the database adapter to the data layer. The result is still a dataset-backed data engine, but without any renderer or control on screen.

procedure TMyService.LoadProducts;
begin
  FData := TTMSFNCDataGridData.Create;

  Adapter.DataSource := DataSource1;     // TDataSource attached to FDQuery1
  Adapter.AutoCreateColumns := True;

  FData.Adapter := Adapter;

  FDQuery1.Open;                         // records are loaded into FData

  FData.Filter.Clear;
  FData.Filter.Add(COL_CATEGORY, gftEqual, 'Meat');
  FData.ApplyFilter;

  FData.Sort(COL_PRICE, gsdDescending);
  FData.SaveToCSVData('filtered-products.csv', ',');
end;

This is the database equivalent of loading JSON or CSV into FData: once the records are in the data layer, the rest of the processing code can stay the same. For exports, reports, validation jobs, and tests, that can be cleaner than creating a visual grid just to reach the data operations.

Choosing Fields and Column Behavior

Automatic columns are convenient during prototyping, but production screens often need a more curated shape: hide technical fields, reorder columns, use friendly headers, or render specific field types with richer UI.

The adapter column collection lets you decide exactly which fields appear and how they are presented:

Adapter.AutoCreateColumns := False;

with Adapter.Columns.Add do
begin
  FieldName := 'ProductName';
  Header := 'Product';
end;

with Adapter.Columns.Add do
begin
  FieldName := 'Price';
  Header := 'Unit Price';
end;

Individual adapter columns can also be configured for more specialized rendering:

Adapter.Columns[2].HTMLTemplate    := '<b>{Name}</b>';
Adapter.Columns[3].PictureField    := True;   // BLOB field as image
Adapter.Columns[4].ProgressField   := True;   // numeric field as progress bar
Adapter.Columns[5].UseLookupEditor := True;   // lookup field as drop-down

For conversion logic, the adapter exposes OnFieldToData and OnDataToField. That gives you a clean place to format database values before they enter the grid, or to translate edited grid values before they are posted back to the dataset.

A Complete Processing Flow

A typical headless workflow can be surprisingly small: load records, apply business filters, sort the result, and export it.

FData.ClearData;
FData.FixedRowCount       := 1;
FData.Options.IO.StartRow := 1;

FData.LoadFromJSONData(
  JSONPath,
  '', '',
  ['id', 'name', 'category', 'price', 'stock']);

FData.Filter.Clear;
FData.Filter.Add(COL_CATEGORY, gftEqual, 'Meat');
FData.ApplyFilter;

FData.Sort(COL_PRICE, gsdDescending);
FData.SaveToCSVData('filtered-products.csv', ',');

No visual control is required, but the data behavior remains consistent with the grid users see elsewhere in the application.

Sample

https://www.tmssoftware.com/download/DataLayerDemo.zip

Conclusion

TTMSFNCDataGridData gives you the data-processing side of TTMSFNCDataGrid as a standalone layer. You can load JSON or CSV, apply filters, sort rows, group data, calculate aggregations, read typed values, and export the result without placing a grid on screen.

For applications that need background exports, automated tests, reporting pipelines, or non-visual data preparation, this is a clean way to reuse the same proven data layer that powers the visual grid. It keeps your logic testable, your UI optional, and your data workflow ready for both desktop and web applications.

Introduction

procedure TForm2.InitGrid;
begin
  WebDataGrid1.Clear;
  WebDataGrid1.ColumnDefs.Clear;

  WebDataGrid1.ColumnDefs.Add;
  WebDataGrid1.ColumnDefs.Add;
  WebDataGrid1.ColumnDefs.Add;
  WebDataGrid1.ColumnDefs.Add;

  WebDataGrid1.ColumnDefs[0].HeaderName := 'Product';
  WebDataGrid1.ColumnDefs[0].EditModeType := cetCombobox;
  WebDataGrid1.ColumnDefs[0].Editable := true;
  WebDataGrid1.ColumnDefs[0].Field := 'Product'; 
  ....
end;

var
  dgs: TDGSelectCellEditorCollectionItem;

  begin
    dgs := WebDataGrid1.ColumnDefs[0].SelectOptions.Add;
    dgs.Value := 'Delphi';
    dgs := WebDataGrid1.ColumnDefs[0].SelectOptions.Add;
    dgs.Value := 'C++Builder';
    ....
  end;

procedure TForm2.Recalc(RowIndex: integer);
var
  q,p: integer;
begin
  p := integer(WebDataGrid1.CellByName[RowIndex, 'Price']);
  q := integer(WebDataGrid1.CellByName[RowIndex, 'Quantity']);
  WebDataGrid1.CellByName[RowIndex, 'Total'] := p * q;
end;

procedure TForm2.WebButton1Click(Sender: TObject);
begin
  WebDataGrid1.InsertNewRow;
  WebDataGrid1.CellByName[WebDataGrid1.RowCount - 1, 'Product'] := 'Delphi';
  WebDataGrid1.CellByName[WebDataGrid1.RowCount - 1, 'Quantity'] := 0;
  WebDataGrid1.CellByName[WebDataGrid1.RowCount - 1, 'Price'] := 123;
end;

procedure TForm2.WebButton2Click(Sender: TObject);
begin
  WebDataGrid1.Clear;
  WebDataGrid1.ColumnDefs.Clear;

  WebDataGrid1.ColumnDefs.Add.Field := 'Brand';
  WebDataGrid1.ColumnDefs.Add.Field := 'Model';
  WebDataGrid1.ColumnDefs.Add.Field := 'Type';

  WebDataGrid1.LoadFromJSON(
    'https://download.tmssoftware.com/tmsweb/demos/' +
    'TMSWEB_ResponsiveGrid/carsfull.json');
end;

procedure TForm2.DGCustomDataAdapter1GetRows(Params: TJSGetRowsParams);
var
  I: Integer;
  RowData: TJSArray;
begin
  RowData := TJSArray._of;

  for I := Params.StartRow to Params.EndRow do
  begin
    RowData.push(new([
      'Id', I + 1,
      'Data', 'Row Number ' + IntToStr(I)
    ]));
  end;

  DGCustomDataAdapter1.GetRowsSuccessful(
    RowData,
    10000,
    Params);
end;

procedure TForm2.WebButton1Click(Sender: TObject);
begin
  WebStellarDataStoreClientDataset1.Active := true;
end;