FontCreator is the font editor from High-Logic B.V. It is written entirely in Delphi, has been downloaded more than five million times and ships in 17 languages, including Arabic and Hebrew, Japanese, Korean and both Chinese scripts. The Windows version is a VCL application with 88 forms. The macOS version is built with FireMonkey.

All of those languages run on TMS FNC Localization. That is no coincidence: the product grew out of the localization layer that High-Logic built for FontCreator, and developer Erwin Denissen shaped it together with TMS. This customer story covers how High-Logic set it up, what they prepared before translating and how it performs.

EnglishDutchChinese (Simplified)

The challenge

High-Logic had localized FontCreator for years with a layer Erwin wrote himself: a folder of language files and a manager that walked each form and replaced its string properties. It did the job, but it had no editor and no tooling, and no other Delphi developer could use it.

And FontCreator is not a small application. Every language holds about 3,850 translatable strings. The macOS version has its own forms, with different property names than the VCL version. Each language has its own plural rules, and Arabic and Hebrew run right to left.

“Many of our users do not read English, and those who do still read their own language faster and with less effort.”

Erwin Denissen, High-Logic B.V.

Building it together with TMS

Instead of keeping the layer to themselves, Erwin contacted Bruno at TMS. Together they took what High-Logic had, improved it and turned it into TMS FNC Localization, a product every Delphi developer can use. FontCreator now runs on it, on Windows and on macOS.

“It was not designed in the abstract. Every part of it exists because a real application needed it.”

Erwin Denissen, High-Logic B.V.

How the parts fit together

FontCreator carries one component: the localizer, on the main form. That is what the shipped application contains. The Localization Editor opens from the right-click menu of a form in the IDE. TMS FNC Localization also has a collector component that holds the editor’s settings for a project, but FontCreator does not need one.

Collecting the text

The editor walks the forms the project declares and builds a model of every translatable property it finds. On a real application the first run finds far more than the visible text, because many string properties are never read by a user: internal keys, format strings and names that happen to be published. Exclusion rules by class and by property filter those out. For FontCreator, writing the rules took about an hour, and everything after that was review.

Lists that the application fills at run time are the other source of noise. FontCreator’s font properties page has a combo box with more than 1,400 vendor IDs that must not be translated. From the grid you can ignore a whole list, component or form in one go, and anything collected below it later stays ignored too.

For the Windows version this produced:

Choosing the languages

The supported languages are a list on the editor’s Languages tab. One of them is the source language, English for FontCreator. Every other language gets a row with its name, a language tag such as nl, de or zh-CN, and its plural rule. The tab also shows how far each translation is.

Forms that are ready for every language

Translated text is not the same length as English. German and Finnish run long, Chinese runs short. A form that only looks right with the English caption breaks when it is translated, and no localization component can fix that. So High-Logic prepared its forms first.

“This is the part people skip, and then blame the tool.”

Erwin Denissen, High-Logic B.V.

GermanDutchChinese (Simplified)

According to Erwin, an afternoon of work on this makes the rest go smoothly.

Text in code: snippets

Messages, prompts, status text and anything built at run time come from code. For that text FontCreator uses snippets: named constants with their default English text, declared once and used wherever they are needed.

SnippetGlobalTextCancelling: TTMSFNCSnippetRec =
  (Name: 'GlobalText.Cancelling'; DefaultText: 'Cancelling...');

Snippets also connect the two platforms. FontCreator for Windows and FontCreator for macOS are separate projects with separate forms, and the property names differ: VCL has Caption where FMX has Text. Form translations can therefore not be shared, but snippets can, because they are keyed by name. 532 snippets exist under the same name in both versions, and their translations carry over unchanged.

macOS, EnglishSettings, EnglishSettings, German

Resource strings and message dialogs

Delphi’s resourcestring never had a good answer outside Windows resource DLLs, which do not work for a cross-platform application. TMS FNC Localization takes a different route.

There is no code at the call site, nothing is generated into the project and no source is scanned. ShowMessage(SCannotOpenFile) is translated simply because SCannotOpenFile is a resourcestring, on Windows and macOS from the same files. Two resourcestrings with the same English text stay separate, so an Open in a menu and an Open in a dialog title can get different Dutch words.

The same hook covers the standard message dialogs. VCL builds their buttons and titles from resourcestrings in Vcl.Consts, which the localizer ties to a shared set of dialog snippets, and FireMonkey asks its own translation hook, which the localizer also answers. MessageDlg, ShowMessage and InputQuery show Yes, No and Cancel in the user’s language without extra code. The exception is FireMonkey on Windows, where Windows itself supplies the standard buttons in the Windows language.

Read more about this in Translate Your Delphi Resourcestrings with TMS FNC Localization 0.9.4.0 BETA.

Translating with AI

The editor has an AI Translate button. On the AI Settings tab you pick a service and enter an API key. These services are supported, including Ollama and llama.cpp for a model on your own machine:

OpenAIClaudeGeminiGrokMistralDeepSeekPerplexityOpenRouterOllamallama.cpp

AI Translate sends everything that is not translated yet, or whose English text changed, in batches. Each text travels with its component and property name, so a “Right” on an alignment button and a “Right” in a validation message get different words. Placeholders such as %s and %d, HTML tags and & access keys are kept, and number snippets come back with the plural forms the language needs.

What a release ships

FontCreator uses LANG files of about 290 KB each. At startup the localizer reads only the header of each file to build the language list, and the full file is read only when that language is selected.

On Windows the files sit next to the executable. On macOS they go inside the application bundle, where the Deployment manager puts them. The editor’s Info tab shows, for the selected platform and build configuration, where the localizer will look, where deployment puts the files, whether those agree, and when the translations were last exported. When the application runs from the IDE, the localizer reads the exported files straight from the project’s export folder, so there is nothing to copy.

Performance

High-Logic measured a release build of FontCreator outside the IDE, with a font and three dialogs open, and took the median of seven runs:

Startup stays fast however many languages ship, because only a short header of each LANG file is read. Of the 223 ms for a language switch, about 19 ms is the localizer walking the component tree and assigning text. The rest is the VCL resizing and repainting the controls whose captions changed.

The results

FontCreator now runs entirely on TMS FNC Localization instead of the layer High-Logic once wrote for itself. It ships in 17 languages on Windows and macOS, and every language holds about 3,850 strings.

Keeping all those languages up to date has become a matter of review. Once the exclusion rules were in place, what remained was checking translations. AI Translate prepares the first pass, and 532 snippets are translated once for both platforms. Hindi and Hungarian are already set up in the editor and stay Excluded until their translations are ready.

For users, changing language is quick: a full language switch takes about 223 ms, and making all 17 languages available at startup takes 7.2 ms.

“We built this because we needed it, and it is now doing the job in an application with 88 forms, two platforms, 17 languages and five million downloads behind it.”

Erwin Denissen, High-Logic B.V.

Erwin’s advice: start with one form

Pick one form. Set the labels so they do not auto-size, give the check boxes room and check that nothing assigns a caption from code. Drop the localizer on your main form, open the editor, add your languages and write your exclusion rules. Let AI Translate do a first pass, review it, and ship that one form translated.

“The first form teaches you your own rules. After that it is mostly review.”

Erwin Denissen, High-Logic B.V.

Try TMS FNC Localization

TMS FNC Localization is available now as version 0.9.4.0 BETA and works in VCL, FMX and TMS WEB Core applications, in Delphi and C++Builder. Everything about getting started is on the product page.

Discover TMS FNC Localization

Questions about localizing your own application? Let us know:

Sooner or later, a successful Delphi application meets a customer who needs it to work a little differently. A discount rule that depends on the region. An extra validation before an invoice is saved. A report column computed with a formula of their own. A menu command that exports data to a partner's format.

You can build each of these into the application, and ship a new version to every customer for a rule only one of them needs. Or you can make that part of the application scriptable, and let the rule be written - by your support team, a consultant, or the customer's own IT staff - without recompiling anything.

Scripting has one practical question, though: in what language will those people write? Most of them have never written Object Pascal. Almost all of them have written some JavaScript.

A quick introduction to TMS Scripter

TMS Scripter is a scripting engine for Delphi applications. It runs scripts inside your application at runtime and gives them access to the objects, classes and functions that you choose to expose. It also includes an IDE that you can embed in your application, with a code editor, a form designer and a debugger, so your users can write and test their scripts where they use them.

Until now, scripts could be written in Pascal or Basic syntax. TMS Scripter 9.0 adds JavaScript.

What JavaScript support means

JavaScript scripts use the syntax people already know: function, var, let and const, if/else, for, while and do..while, switch, try/catch/finally, throw, ++, +=, the ?: operator, array literals and // comments.

They run on the same engine as the Pascal and Basic scripts. That has a few practical consequences:

• Everything you expose to scripts is available in JavaScript. Classes registered by RTTI, objects added with AddObject, libraries, functions, events - the same registration serves the three languages.
• Nothing new to deploy. There is no external JavaScript runtime, DLL or package to ship with your application.
• The languages work together. A JavaScript script can use a unit written in Pascal or Basic, and the other way around.
• The tooling is the same. The Scripter IDE supports JavaScript units (.jsc files), with syntax highlighting, code completion, forms declared in script, and debugging with breakpoints and watches.

Hello, JavaScript

This is a complete console application that runs a JavaScript script:

program HelloScripter;

{$APPTYPE CONSOLE}

uses
  System.SysUtils,
  System.Variants,
  atScripter;

var
  Scripter: TatScripter;
  ScriptResult: Variant;
begin
  Scripter := TatScripter.Create(nil);
  try
    // The language of the script: slJavaScript, slPascal or slBasic
    Scripter.CurrentScript := Scripter.AddScript(slJavaScript);

    // In a console application, ShowMessage writes to the console
    Scripter.SourceCode.Text :=
      'var name = "World";' + sLineBreak +
      'ShowMessage("Hello, " + name + "!");' + sLineBreak +
      'return 6 * 7;';

    // Compiles and runs the script, and returns the value given by its return statement
    ScriptResult := Scripter.ExecuteAsVariant;
    WriteLn('The script returned ', VarToStr(ScriptResult));
  finally
    Scripter.Free;
  end;
end.

AddScript creates a script in the language you choose. If most of your scripts are in JavaScript, set DefaultLanguage to slJavaScript instead.

A business rule in JavaScript

Back to the discount rule. The rule lives in a script file that can change without a new build of the application:

// pricing.jsc
function discount(total, customerType) {
  if (customerType == "VIP")
    return 15;
  if (total >= 100)
    return 10;
  return 0;
}

The application compiles the script once, and calls the function whenever it prices an order:

uses
  atScripter;

type
  TPricingRules = class
  private
    FScripter: TatScripter;
  public
    constructor Create(const RulesFile: string);
    destructor Destroy; override;
    function Discount(Total: Double; const CustomerType: string): Double;
  end;

constructor TPricingRules.Create(const RulesFile: string);
begin
  inherited Create;
  FScripter := TatScripter.Create(nil);
  FScripter.CurrentScript := FScripter.AddScript(slJavaScript);
  FScripter.SourceCode.LoadFromFile(RulesFile);

  // Compiled once; its functions can then be called as often as needed
  FScripter.Compile;
end;

destructor TPricingRules.Destroy;
begin
  FScripter.Free;
  inherited;
end;

function TPricingRules.Discount(Total: Double; const CustomerType: string): Double;
begin
  Result := FScripter.ExecuteSubroutineAsVariant('discount', [Total, CustomerType]);
end;

When the customer wants 5% off for orders from 50, someone edits pricing.jsc. The Delphi code doesn't change.

Your Delphi objects, in JavaScript

Rules become much more useful when they work with the objects of your application. Here is an ordinary Delphi class - nothing in it knows about Scripter:

type
  TOrder = class
  // private fields and getters omitted
  public
    function AddItem(const AProduct: string; AQuantity: Integer; AUnitPrice: Double): TOrderItem;
    function Total: Double;
    property Number: Integer read FNumber;
    property Customer: TCustomer read FCustomer;
    property Items[Index: Integer]: TOrderItem read GetItem;
    property ItemCount: Integer read GetItemCount;
  end;

One call to DefineClassByRTTI makes its public members available to scripts, and AddObject gives the script an instance to work with:

uses
  System.TypInfo, atScript, atScripter;

procedure RunOrderScript(Scripter: TatScripter; Order: TOrder);
begin
  // True also registers the classes used by TOrder: TCustomer and TOrderItem
  Scripter.DefineClassByRTTI(TOrder, '', [mvPublic, mvPublished], True);
  Scripter.AddObject('Order', Order);
  Scripter.Execute;
end;

The script uses the order with its Delphi names - properties, methods, indexed properties, and the objects they return:

Print("Order " + IntToStr(Order.Number) + " for " + Order.Customer.Name);

Order.AddItem("Croissant", 3, 2.5);
var juice = Order.AddItem("Orange juice", 1, 3);
juice.Quantity = 2;

for (var i = 0; i < Order.ItemCount; i++) {
  var item = Order.Items[i];
  Print(IntToStr(item.Quantity) + " x " + item.Product + ": " +
    FormatFloat("0.00", item.Total()));
}
Print("Total: " + FormatFloat("0.00", Order.Total()));

(Print is not a Scripter routine: it is a function that the demo application exposes to its scripts, to write to its output pane. Your application can expose its own functions the same way.)

Events work the same way. A script function can handle an event of any object, by assigning its name to the event property:

function SaveClick(Sender) {
  ShowMessage("Saving " + edName.Text);
}

btSave.OnClick = "SaveClick";

Pascal, Basic and JavaScript, together

If you already have Pascal or Basic scripts, you don't have to rewrite them to start using JavaScript. Each script has its own language, and scripts use each other by unit name, whatever language each one is written in:

procedure AddUnit(Scripter: TatScripter; Language: TScriptLanguage;
  const AUnitName, FileName: string);
var
  ScriptUnit: TatScript;
begin
  ScriptUnit := Scripter.AddScript(Language);
  ScriptUnit.UnitName := AUnitName;
  ScriptUnit.SourceCode.LoadFromFile(FileName);
end;

procedure AddUnits(Scripter: TatScripter);
begin
  AddUnit(Scripter, slPascal, 'TaxRules', 'TaxRules.psc');
  AddUnit(Scripter, slBasic, 'Formats', 'Formats.bsc');
  AddUnit(Scripter, slJavaScript, 'Discounts', 'Discounts.jsc');
end;

A JavaScript script then imports the three units and calls their functions as if they were its own:

import TaxRules, Formats, Discounts;

var Net = ApplyDiscount(100, 10);  // Discounts.jsc
var Total = AddTax(Net);           // TaxRules.psc
Print(FormatPrice(Total));         // Formats.bsc

A team can keep its tested Pascal routines and write new scripts in JavaScript, or let each user write in the language they prefer.

Forms, the IDE and debugging

JavaScript scripts can declare forms, too. A //$FORM directive links the script to a form file. The components of the form are available by name, the global variables of the script become properties of the form, and its functions become methods:

//$FORM TCustomerForm, CustomerForm.dfm
import Controls;

var CustomerId;

function Init(Id) {
  CustomerId = Id;
  Caption = "Customer " + IntToStr(Id);
  edName.OnChange = "NameChange";
}

function NameChange(Sender) {
  Caption = "Customer " + IntToStr(CustomerId) + ": " + edName.Text;
}

Another script creates and shows instances of the form like any other class:

import Classes, Controls, Forms, CustomerForm;

var Form = new TCustomerForm(Application);
Form.Init(1);
Form.edName.Text = "Alfreds Futterkiste";
if (Form.ShowModal() == mrOk)
  ShowMessage("Saved " + Form.edName.Text);
Form.Free();

The Scripter IDE handles JavaScript units like Pascal and Basic ones: you design the form, write the code with highlighting and code completion, and run or debug the project. This is a complete game written in JavaScript, running from the IDE:

If you build your own script editor instead, the new TScrJavaScriptMemoStyler component gives the TScrMemo editor JavaScript syntax highlighting:

ScrMemo1.SyntaxStyles := ScrJavaScriptMemoStyler1;

JavaScript syntax, Delphi objects

It is worth being clear about what this is: the syntax of JavaScript for scripting your Delphi application, not a browser or Node.js runtime. Scripts work with the objects your application provides, not with npm packages or the DOM. That keeps scripts small and focused on your domain, and keeps the behavior consistent with Pascal and Basic scripts. A few differences follow from it:

• Names are not case-sensitive, as in Delphi: Order.Total, order.total and ORDER.TOTAL are the same.
• Objects are Delphi objects. new TStringList() calls the constructor, Free() destroys the object. Object literals, classes, prototypes and closures are not supported.
• There is no JavaScript standard library (Math, JSON, Date, string methods). Scripts use the built-in routines - IntToStr, FormatFloat, Copy, Now and many others - and the libraries your application registers.
• catch has no parameter: the error is available in LastExceptionMessage.

The full list is in Differences from standard JavaScript. The JavaScript language reference is written for script authors, so you can hand it to the people who write the scripts of your application.

Where it fits

• Business rules and formulas - prices, discounts, taxes, commissions, validations - that change more often than your release cycle.
• Plugins and extensions: let customers add menu commands, handle events and automate tasks in your application.
• Per-customer customization of a product that ships the same executable to everybody.
• Automation and macros for power users who know JavaScript from spreadsheets, browsers or web development.
• Gradual adoption: add JavaScript next to your existing Pascal and Basic scripts, without migrating them.

Conclusion

TMS Scripter 9.0 lets the people who customize your application write in the language they most likely already know:

• JavaScript syntax, on the same engine as Pascal and Basic, with nothing new to deploy.
• Full access to your Delphi objects, registered once for all three languages.
• Mixed languages: JavaScript, Pascal and Basic scripts that use each other.
• IDE support: JavaScript units, forms, code completion and debugging.

To learn more, read the JavaScript language reference and the chapter Working with Scripter, see what's new in TMS Scripter 9.0, and visit the TMS Scripter product page. The examples in this post are based on the new demos of TMS Scripter, where every script is available in JavaScript, Pascal and Basic - so you can also compare the three languages side by side.

In part 1 the AI classified a mail from its text alone. Real customer mail carries more: a photo of a warning light, an invoice PDF, a history with the dealership, and in between it all, mail that should never reach a person. This post adds those three layers to the triage of AI Mail Desk, without adding a second AI request.

Photos and PDFs Go Along with the Mail

When TMS FNC Cloud Pack fetches a mail, the server downloads image and PDF attachments right away: Gmail through GetAttachment and OnGetAttachment, Outlook through GetAttachments and OnGetAttachments. Each file is saved next to the server's data and its path is stored on the mail.

At triage time, TTMSMCPCloudAI sends those files with the request. AI Studio picks the right file type from the extension:

FAI.Context.Text := BuildMailPrompt(M);
// Photos and PDFs travel with the request; the model describes them in "attachments"
FAI.ClearFiles;
for Path in M.Attachments do
  if TFile.Exists(Path) then
    FAI.AddFile(Path, FileExtToFileType(Path));
FAI.Execute(M.ID.ToString);

The prompt asks the model to describe what matters for the handler in an attachments field: the warning lights on a dashboard photo, visible damage, or the number, date and amount on an invoice. The model also uses what it sees for the classification itself. A short "my car broke down" with a photo of a red engine warning becomes a confident, urgent maintenance mail.

In the demo inbox, Ellen De Smet's breakdown mail carries a dashboard photo and Nathalie Maes' complaint about a double charge carries the invoice as a PDF, so you can try this with any vision-capable model.

A Customer Memory in SQLite

Every triaged mail is stored in a small SQLite database through FireDAC: who wrote, when, which department, which handler and the one-line summary. When a new mail arrives from a known address, the last few contacts are added to the prompt as Earlier contact, and the AI is told to take them into account. A follow-up on last month's repair is then recognised as a follow-up, not as a new request.

The history also changes the routing. A returning customer goes back to the person who handled their last mail in the same department, as long as that person is still in the routing table:

FQuery.Open('SELECT handler_email, received FROM history WHERE lower(email) = lower(:e) ' +
  'AND department = :d AND source_id <> :s ORDER BY received DESC LIMIT 1',
  [AMail.FromEmail, Ord(AMail.Department), HistoryKey(AMail)]);

If that handler still owns the department, the mail is routed to them and the reason says why. In the demo, Pieter Jacobs asks for a test drive in an Audi Q6 e-tron. The routing table would send that to the Audi salesperson, but Pieter received a quote from Lukas Peeters a month earlier, so the mail stays with Lukas:

A returning customer keeps their contact person: "Returning customer: kept with Lukas Peeters".

The same history is available as an MCP tool, find_customer, so an LLM working the inbox can look up a customer before it answers a question about them.

Spam in the Same Request

A dealership address attracts prize scams, crypto offers and cold sales pitches for search engine optimisation. Rather than a separate filter, the triage asks for two more fields in the same JSON answer: "spam" and "spam_reason". The prompt is explicit about what does not count as spam: a real customer, supplier or job applicant never is, even when the mail is short or rude.

Spam leaves the inbox and waits on its own page, with the reason and a preview. The count shows in the sidebar.

Flagged mails wait for review. Not spam puts a mail back in the inbox; Delete moves it to the mailbox's trash.

Two details keep the filter safe:

Without an AI service, an offline check flags a mail when it contains two or more typical scam or cold-pitch phrases, matched as whole words so that "seo" does not match "Seoul".

Conclusion

None of these additions needs a second model call. The attachments ride along with AddFile, the history is a few lines of SQL and a paragraph in the prompt, and spam detection is two extra fields in the JSON the AI already returns. The result is a triage that sees what the customer sent, knows who they are and keeps the junk away from the team. In the next post, the triaged mail turns into action: drafts, forwards, workshop slots, alerts and translations.

TMS AI Studio is the complete toolkit for bringing AI and the Model Context Protocol to your Delphi applications. Build MCP servers and clients, connect Claude and other assistants to your own tools and data, and add cloud AI to your VCL and FMX apps, all in native Delphi. Discover TMS AI Studio.

TMS FNC Cloud Pack connects your Delphi applications to cloud services such as Gmail, Outlook, Google Calendar, Outlook Calendar, Pushover and many more, with the OAuth sign-in handled for you. Discover TMS FNC Cloud Pack.

In the introduction to AI Mail Desk we met Brightline Motors, a car dealership that lets an AI do the first pass over its mailbox. This post covers the core of that idea: getting mail out of Gmail and Outlook, asking an LLM what each mail is about, and turning the answer into a handler, a priority and a reply.

From a Dutch customer mail to a routed mail with a reply draft, in one AI request.

Fetching Mail from Gmail and Outlook

TTMSFNCCloudGoogleGmail and TTMSFNCCloudMicrosoftOutlookMail handle OAuth, token refresh and the REST APIs. After the first login in a browser, the tokens are stored and the server reconnects by itself. Fetching the inbox is one call per mailbox:

FGmail.GetMails('INBOX', AMax, False);
FOutlook.GetMails('Inbox', AMax);

When the mails arrive, each Cloud Pack message is mapped to a small TTriageMail object that the rest of the system understands: sender, subject, plain-text body, original HTML, the IDs needed to reply in the same thread, and local copies of any photos or PDFs. HTML mails are reduced to plain text for the AI, while the original HTML is kept for forwarding.

One Request per Mail

TTMSMCPCloudAI is TMS AI Studio's component for talking to LLM services. Switching between OpenAI, Claude, Gemini, Mistral, DeepSeek or a local Ollama model is a matter of changing Service; the rest of the code stays the same.

The triage sends one request per mail. The system prompt describes the departments, the brands the dealership sells and the priority rules; the context holds the mail itself:

FAI.SystemRole.Text := BuildSystemPrompt(FRouting);
FAI.Context.Text := BuildMailPrompt(M);
FAI.Execute(M.ID.ToString);

The mail ID is passed as the request ID and comes back in OnExecuted, so the answer is always matched to the right mail, even when several requests are on their way.

Ask for JSON, Not Prose

The prompt asks the model for a single JSON object with fixed fields. That makes the answer easy to check and turns a language model into a predictable classifier:

{"department":"sales|accessories|maintenance|finance|secondhand|other",
 "brand":"<brand or Other>",
 "priority":"low|normal|high|urgent",
 "confidence":<integer 0-100>,
 "summary":"<one short sentence in English for the handler>",
 "reason":"<short explanation of the classification>",
 "reply":"<draft reply to the customer>",
 "appointment":"<YYYY-MM-DD HH:MM or empty>",
 "attachments":"<what the attached photos or documents show>",
 "spam":true|false, "spam_reason":"<why, or empty>"}

A few rules in the prompt do most of the work. Models sometimes wrap JSON in a code fence or add a sentence, so the parser simply takes the outermost object and is forgiving about synonyms such as "service" or "workshop" for maintenance.

A Routing Table, Not Hard-Coded Rules

The AI decides what a mail is about; the routing table decides who handles it. Each rule maps a department and a brand to a handler, and a * brand acts as the fallback for a department:

Department plus brand decides the handler. Brand * is the fallback for a department.

Because the brands in the routing table are also part of the system prompt, the AI can only answer with a brand the dealership actually knows. The handler's signature replaces [SIGNATURE] in the reply, so when a person re-routes a mail to another department, the signature follows automatically.

Confidence and the Human in the Loop

Every result carries a confidence score, shown as a data bar in the inbox grid. Nothing leaves the building on the AI's word alone: the reply is saved as a draft, forwarding starts in dry-run mode, and anyone can re-route a mail by dragging its card to another department on the handler board (or by asking the dashboard's assistant), which recalculates the handler and the signature.

Department, brand, priority and confidence at a glance, with the analysis of the selected mail below.

Works Offline Too

Without an API key the demo falls back to simple keyword rules in four languages. That is deliberately basic: it shows the complete flow without an AI service, and it shows why an LLM is the better classifier. A mail that says "my car makes a noise when braking" in Dutch is easy for a model and hard for a keyword list.

Conclusion

The pattern is short: fetch with TMS FNC Cloud Pack, ask TTMSMCPCloudAI for a fixed JSON shape, and let a routing table you control turn that answer into a person. In the next post, the AI gets more to work with: the photos and PDFs attached to a mail, the customer's history, and a verdict on whether the mail is spam.

TMS AI Studio is the complete toolkit for bringing AI and the Model Context Protocol to your Delphi applications. Build MCP servers and clients, connect Claude and other assistants to your own tools and data, and add cloud AI to your VCL and FMX apps, all in native Delphi. Discover TMS AI Studio.

TMS FNC Cloud Pack connects your Delphi applications to cloud services such as Gmail, Outlook, Google Calendar, Outlook Calendar, Pushover and many more, with the OAuth sign-in handled for you. Discover TMS FNC Cloud Pack.

Collect, translate, apply. That was the promise when we introduced TMS FNC Localization, and it is the promise we intend to keep while pushing the capabilities of each step further!

In this blog post we'll discuss what the TMS FNC Localization 0.9.4.0 BETA update brings as the next milestone: reaching beyond simple property collection, with resourcestring support, custom localization of the editor itself and more choice in how your translations are stored, all moving towards a fully mature tool for handling the localization of your Delphi projects.

Your Resourcestrings Join the Translation Project

Collecting works by walking components and reading their text properties. A resourcestring is not a component property, which meant that until now a collection pass gathered every caption on every form and not a single resourcestring, even though resourcestrings are exactly where the error messages and dialog texts of a serious application tend to live.

With TMS FNC Localization 0.9.4.0 BETA we handle this without parsing a single line of your source code. The compiler already writes the complete list of every resourcestring linked into your binary: the .drc file.

From there, resourcestrings simply become part of the project. They show up in the tree beside your forms and are translated like any other text: manually, with AI assistance or through XLIFF. Only your own units are taken, so the thousands of resourcestrings in the RTL and the frameworks never clutter the list. And the best part is, nothing extra is needed at run time! The collected resourcestrings travel in the language files and are applied dynamically based on your application's selected language.

The Localization Editor Speaks Your Language

A tool for translating applications that is only available in English is a little ironic. So we turned the TTMSFNCLocalizationEditor on itself!

At design time the editor now follows the language of your IDE, when that is one of the built-in languages. Nothing to configure: a German RAD Studio opens a German editor.

At run time you choose, per call:

// Open the editor in one of the built-in languages: 'en', 'de', 'fr' or 'ja'
TMSFNCLocalizationEditor.Execute('ja');

The locale applies to that one call and is reset when the editor closes. It changes the language of the editor only, never the active language of your application.

And if the four built-in languages are not the four you need, the editor can be translated through your own application's translations instead:

// The editor is collected like any other form and follows
// the active language of your application
TMSFNCLocalizationEditor.AllowCustomTranslation := True;
TMSFNCLocalizationEditor.Execute;

With AllowCustomTranslation on, the editor's window is collected like any other form, its messages are registered as snippets under the Editor. prefix, and collection rules for its columns and AI settings are added automatically. From that point the editor is simply part of your translation project, and it follows whatever language your application is in. That matters most when you ship the editor inside your application, so the people correcting a translation can work in their own language.

LANG Files or One JSON File, Your Choice

Until now, translations lived in a single JSON file holding every language together. That is still the default and still the file the editor works against in your project folder. What 0.9.4.0 adds is the ability to export and import one file per language.

A LANG file is plain, line-based text with a short header, named after the language it carries:

; lang.de.lang
_meta.locale = "de";
_meta.language = "Deutsch";
_meta.for = "InvoiceManager";
_meta.exported = "2026-10-28";

MainForm.btnSave.Text = "Speichern";
MainForm.lblCustomer.Text = "Kunde";
ResourceStrings.Invoices.sInvoiceOverdue = "Rechnung überfällig";

Which format suits you depends on what happens to the translations next:

The header is part of the file, so a language file knows which application and which locale it belongs to, which plural forms apply, who contributed to it and when it was exported. Your code does not change either way: the localizer reads whichever format it finds, and when both are present the LANG files take priority!

Workflow Improvements

Along with the new features, TMS FNC Localization 0.9.4.0 BETA brings in various improvements to the workflow!

• Translation files are now generated in and loaded from the project folder when you run from the IDE, instead of accumulating copies in every output folder you build into. This new approach also fits the concept that the translation file belongs to the project version control system.
• TTMSFNCLocalizationComboBox can now offer System language as a choice, so your users can hand the selection back to the operating system and have it stay that way.
• TTMSFNCLocalizationEditor comes with a new Info tab intended for diagnostics purposes for your project.

And as always, we applied a number of fixes for issues that got reported by users during the BETA!

How to Get Started

Download the free trial

Help Us Shape the Final Release

Localization requirements differ enormously between applications. The features in TMS FNC Localization 0.9.4.0 BETA exist because people told us what was missing from their own workflow, so please keep doing that: try it on a new project, or better, on the older one that suddenly needs support for multiple languages!

We are looking forward to seeing what you build with it, and in how many languages!

Describe the grid you want, and let Claude build it. With the new TMS FNC DataGrid plugin for Claude, Claude knows the TMS FNC DataGrid inside out: its columns, editors, filtering, grouping, conditional formatting, database adapter and export components. You ask in plain language, Claude writes the code straight into your form.

The result is less waiting, fewer steps to follow along with, and grid features that work the first time you run your app.

• Less waiting: in our test Claude finished a full-featured grid demo 22% faster.
• Fewer steps: 43% fewer tool calls, so fewer actions to watch or approve along the way.
• Works first time: the projects built with 0 errors on the first build, and every requested grid feature worked at runtime.
• Goes further on your plan: 33% fewer tokens for the same task, so your Claude usage lasts longer.

How to install it

There are two ways to get the plugin. Both give you exactly the same plugin.

Option 1: the public Claude plugin directory (coming soon)

We've submitted the plugin to Anthropic's public Claude plugin directory. Once it's listed, you'll find TMS FNC DataGrid there and add it to your Claude account with one click. It's then available in Claude Code, the Claude desktop app and Cowork, without typing a single command. We'll announce it here as soon as it's live.

Option 2: our marketplace on GitHub (available today)

Don't want to wait? The plugin is already available from our public plugin marketplace on GitHub. In Claude Code, run:

/plugin marketplace add tmssoftware/tms.claude.plugins
/plugin install tms-fnc-datagrid@tms-software

That's all. There's nothing to configure and you don't have to mention the plugin in your prompts: as soon as you ask Claude to work on a TMS FNC DataGrid, it uses the plugin by itself.

Just ask

The plugin adds four skills. Use them by name, or simply describe what you want:

• Get started: "Add a TMS FNC DataGrid to my main form with some sample products." Claude detects whether your project is VCL, FMX or TMS WEB Core and adds a working grid with data.
• Unlock a feature: "Group the grid by Category and show a total per group." Pick from grouping, a filter row, conditional formatting, checkboxes and progress bars in cells, merged cells, database binding, master-detail, and Excel, PDF or print export. Claude asks one or two questions about your data and writes the feature into your form.
• Review: "Check my grid code." Claude goes through your existing grid code and suggests improvements.
• DataGrid knowledge: works in the background whenever you or Claude touch TTMSFNCDataGrid code.

Not just simple tasks

Adding a grid with a few rows is easy. The plugin really pays off on bigger requests, the kind that normally take an afternoon of reading documentation and trying things out. Here is the request from our benchmark, written the way you would type it yourself: ten grid features in a single prompt. The numbers mark its parts, explained below.

Here is what each part of the prompt does, and what the plugin brings to it:

Same polished result, less waiting

To see what that looks like in practice, we asked Claude for a styled Sales Dashboard in FireMonkey, once with and once without the plugin. The brief covered order lines grouped by region with revenue totals, a filter row, colour-coded margins, data bars, a checkbox column, a merged band header, a totals footer, a navy corporate style and Excel and PDF export buttons.

Both versions ended up looking professional. With the plugin, Claude got there in 12.4 minutes and 93 tool calls, including two short follow-up prompts to fine-tune the Paid column and the footer. Without the plugin it took 14.6 minutes and 128 tool calls. Same dashboard, less time spent waiting and following along.

Faster, with less effort: the numbers

We gave Claude the same assignment with and without the plugin: build a new FireMonkey demo of the DataGrid with ten features, from sample data, sorting, a filter row and grouping to conditional formatting, cell controls, editing, merged cells, and Excel and PDF export. Claude had to keep going until the project compiled with Delphi 13. We then rebuilt every project and checked every feature.

Why the difference? Without the plugin, Claude has to search the grid's source code for every property name, event and option before it can use them. With the plugin, it already knows them. That means fewer detours, less time watching Claude look things up and more time seeing your grid come together.

What's next

The TMS FNC DataGrid is the first product with its own Claude plugin, and our marketplace is ready for more. We plan to cover more TMS products the same way. Let us know in the comments which one you'd like to see next.

Try it today

Install the plugin, ask Claude to add a grid to your next form, and see the difference for yourself:

• Install today from GitHub: tmssoftware/tms.claude.plugins
• Soon in the Claude plugin directory
• The TMS FNC DataGrid documentation
• The TMS support forum

TMS FNC UI Pack brings more than 70 cross-framework components to VCL, FireMonkey and TMS WEB Core, including the TMS FNC DataGrid with sorting, filtering, grouping, conditional formatting, database binding and Excel/PDF export. Learn more about TMS FNC UI Pack.

AI Mail Desk is a Delphi showcase that hands that first pass to an AI. It fetches mail from Gmail and Outlook, lets an LLM classify every message and write a reply in the customer's language, routes it to the right person and saves the reply as a draft for a human to check. The dealership in the demo, Brightline Motors, is fictional; the components are not.

Incoming mail is classified, routed and answered before anyone opens it.

What the Demo Does

One Server, Many Clients

The heart of the system is GarageMailMCP.exe, a console application built with TMS AI Studio. It owns the inbox, the routing table, the settings, the work queues and the customer history, and every part of it is available as an MCP tool. The FireMonkey dashboard is one client of that server; an LLM is another. What Claude changes in the routing table shows up in the dashboard within a second, and the other way round.

The triage server owns the state; the dashboard and any LLM work through the same MCP tools.

That split is more than an architecture diagram. Because every action is a tool, the same server can be operated by a person clicking buttons, by an assistant inside the dashboard, or by an automation that triages new mail every few minutes and only leaves the decisions to people.

Three Product Families, One Application

Each part of the demo leans on a different TMS product:

The dashboard inbox: department badges, priority, AI confidence and the analysis of the selected mail.

Try It Without a Mailbox

You do not need a Google or Microsoft account to explore the demo. Start the server, start the dashboard and click Get mail: with no mailbox connected, thirteen realistic customer mails in English, Dutch, French and German arrive, plus two spam mails. Pick an AI service and API key on the Settings page, or choose the offline keyword rules to see the flow without an AI.

Download AI Mail Desk

The complete demo is on GitHub. Run the prebuilt binaries to try it in a few minutes, or clone the repository and build it yourself to follow along with the code in this series.

The release has two zips, one per edition:

• AIMailDesk-Garage-Win32.zip: the Brightline Motors showcase that this series is about.
• AIMailDesk-Configurable-Win32.zip: the configurable edition. It contains no car dealership: you pick a business template on its Setup page and define your own categories, routing and replies.

git clone https://github.com/tmssoftware/tms.demos.aimaildesk.git

TMS FNC Component Studio  Free trial

You can now try TMS FNC Component Studio with a free trial from its product page. One installer puts all 13 FNC products in your IDE, so you can test them together in your own projects instead of installing a separate trial for each product.

FNC stands for Framework Neutral Components: components for Delphi and C++Builder that you can put on a VCL form, an FMX form or a TMS WEB Core page. You keep one codebase for Windows, macOS, Linux, iOS, Android and the web.

VCLFireMonkeyTMS WEB Core

Download the free trial

What is in the trial

The trial contains the same 13 products as the full TMS FNC Component Studio.

User interface and data

Charts, dashboards and planning

Maps and diagrams

Cloud and communication

Web technology and application tools

Foundation

How to get the trial

After the trial

Questions while you test?

Let us know how the FNC components work in your projects:

Start your free trial

TMS FNC Component Studio is one license for all FNC components: UI controls, charts, maps, diagrams, cloud access and more, with full source code, for VCL, FireMonkey and TMS WEB Core. Learn more about TMS FNC Component Studio.

If your TMS license expired more than 30 days ago, this is a good time to bring it back. From Monday 26 October to Friday 6 November 2026, the promo code HALLOWEEN2026 takes 31% off the restart price of any product.

Why restart your license

Your TMS components keep working after your license expires, but you stay on the version you had on that day. A restart brings you up to date and keeps you there.

Recent releases of our most popular products

Here is a selection of what we released in recent months. If your license expired before these releases, a restart gives you access to them.

How to restart your license

Not sure how to restart your license? Email us at sales@tmssoftware.com.

Renewing a TMS license used to mean keeping an eye on the expiry date and placing a new order in time. From now on, you can let it renew on its own. Choose Subscribe when you renew, and your license is extended automatically each time its license period ends.

Your license stays active, so new versions and support keep coming without a gap. You can choose the subscription while your license is still active, and up to 30 days after it expires.

Products with the subscription option

Seven products can be renewed as a subscription. The table shows which license types qualify for each product. The license period is one year for all of them, except TMS VCL Subscription, which has a two-year license period.

How to subscribe

Log in to your TMS account and open the My Products page. Each product with the subscription option shows two renewal options, both at the same discounted price:

• Extend adds one license period. After that, you renew again yourself.
• Subscribe adds that period too, and keeps renewing your license automatically after that.

Click SUBSCRIBE to switch your license over to a subscription, and follow the instructions on the checkout page.

The two renewal options for TMS ALL-ACCESS on the My Products page.

Frequently asked questions

I already have a subscription. Do I need to do anything?

No. Your license renews automatically.

Can I buy a new license as a subscription?

No. The subscription is only offered when you renew a license you already own.