DEV Community: Sempare Limited

Building Ultra-Lightweight Docker Images with Free Pascal: From Scratch in just over 1MB! 🚀

Sempare Limited — Mon, 25 Aug 2025 12:15:26 +0000

Ever wondered how small you can make a Docker image for Free Pascal based of Docker scratch? In this article I'll show you how to create a fully functional application using Free Pascal and containerise it that fits in just 1.24MB - smaller than most profile pictures!

Why This Matters

In the world of microservices and containerised applications, image size matters:

Faster deployments - Less data to transfer
Reduced storage costs - Especially important at scale
Improved security - Smaller attack surface
Better performance - Less memory footprint

The Magic: Docker's `scratch` Image

Docker's scratch image is literally empty - it contains absolutely nothing. This makes it the ultimate starting point for minimal containers, but it also means your binary needs to be completely self-contained.

The Setup

Here's what we're working with:

hello.pas - A simple Free Pascal program that makes an HTTP request:

program hello;

uses
    SysUtils,
    fphttpclient;
begin
    writeln(TFPCustomHTTPClient.SimpleGet('http://www.somedomain.com'));
end.

fpc.cfg - Compiler configuration for static linking:

-O4 
-Os 
-Xs 
-XX 
-XS 
-k-static
-Fu/usr/lib/fpc/3.2.2/units/aarch64-linux/fcl-net
-Fu/usr/lib/fpc/3.2.2/units/aarch64-linux/fcl-web 
-Fu/usr/lib/fpc/3.2.2/units/aarch64-linux/fcl-base
-Fu/usr/lib/fpc/3.2.2/units/aarch64-linux/rtl-extra 
-Fu/usr/lib/fpc/
-Fu/usr/lib/fpc/3.2.2/units/aarch64-linux/rtl-objpas

Key compiler flags explained:

-O4 -Os: Maximum optimization for size
-Xs -XX -XS: Strip symbols and create smart-linked executable
-k-static: Static linking (crucial for scratch containers)

The Multi-Stage Dockerfile

FROM freepascal/fpc:3.2.2-alpine-3.19-full AS build

RUN apk add --no-cache musl-dev 

RUN mkdir /build

WORKDIR /build

COPY fpc.cfg /etc/
COPY hello.pas /build/

RUN fpc hello.pas 

FROM scratch
COPY --from=build /build/hello /app/hello
CMD ["/app/hello"]

This uses a multi-stage build:

Stage 1: Use the full Free Pascal Alpine image to compile
Stage 2: Copy only the compiled binary to scratch

Building and Testing

# Build the image
docker build -t hello-fpc .

# Check the size
docker images hello-fpc
# Output: hello-fpc latest 1.24MB

# Run it
docker run hello-fpc
# Output: Full HTML response from the test site!

Why This is So Cool

Incredible Size Efficiency: At 1.24MB, this is smaller than:
- A single high-resolution photo
- Most JavaScript frameworks
- Basic Python/Node.js containers (often 100MB+)
Security Benefits:
- No shell, package manager, or unnecessary tools
- Minimal attack surface
- Only contains your application
Performance:
- Lightning-fast container startup
- Minimal memory usage
- Perfect for serverless/edge computing

Free Pascal Advantages

Free Pascal shines in this use case because:

Static compilation: Creates self-contained binaries
Small runtime: No large runtime environment needed
Fast execution: Compiled code runs efficiently
Rich libraries: Full HTTP client capabilities built-in
Cross-platform: Same code works on multiple architectures

Comparison with Other Languages

Language	Typical Container Size	Notes
Free Pascal	1.24MB	This example
Go	5-20MB	With scratch base
Rust	10-30MB	With alpine/scratch
Node.js	150-300MB	Even with Alpine
Python	100-500MB	Various base images
Java	200-400MB	JRE required

Real-World Applications

This approach is perfect for:

Microservices: Minimal overhead
Edge computing: Fast deployment
IoT applications: Resource constraints
Serverless functions: Quick cold starts
Health check services: Minimal footprint
API gateways: High performance needs

Tips for Success

Always use static linking (-k-static flag)
Optimize for size (-Os, -O4 flags)
Strip symbols (-Xs, -XX flags)
Test thoroughly - No debugging tools in scratch!
Handle errors gracefully - No shell for troubleshooting

Conclusion

Free Pascal + Docker scratch images = Ultimate efficiency!

At just 1.24MB, we've created a fully functional web client that's:

✅ Secure by design
✅ Lightning fast
✅ Resource efficient
✅ Secured intellectual property

This approach proves that modern applications don't need to be bloated. Not bad when working with with your daddy's pascal! ;)

Thank you to our supporters!

We need your help to maintain our Sempare Template Engine (https://github.com/sempare/sempare-delphi-template-engine).

Support us via GitHub Sponsors (https://github.com/sponsors/sempare) or Stripe (https://buy.stripe.com/aEU7t61N88pffQIdQQ).

Some interesting developments are coming regarding our Sempare Boot framework with native support in Free Pascal (currently self funded).

What's the smallest Docker image you've ever created?

The Sempare Template Engine for Delphi: Advanced Template Registry Features

Sempare Limited — Wed, 20 Nov 2024 18:21:28 +0000

The Sempare Template Engine (available at https://github.com/sempare/sempare-delphi-template-engine and GetIt) is a versatile templating system designed specifically for Delphi developers to streamline the creation and management of dynamic HTML, text, or any other text-based output formats. Whether you are building web applications, reports, or email templates, the Sempare Template Engine offers a powerful yet straightforward solution that integrates with minimal boilerplate into Delphi projects. Having been around since 2019, the template engine has matured into a robust tool with many features for you to explore.

In this article, we will explore the various ways in which templates can be accessed using the Template Registry that accompanies the Sempare Template Engine.

This article assumes you are already familiar with the template engine and are interested in some of its more advanced features. Introductory topics on the engine are covered elsewhere and in other articles.

Introduction: Why Use a Template Registry?

Managing templates in larger applications often leads to repetitive boilerplate code, especially when dealing with multiple sources like files, streams, or resources. This can make the process error-prone and time-consuming. The Template Registry addresses this challenge by offering a general and consistent approach for template access management.

The Sempare Template Engine’s main entry point is the Template helper class. Under the hood, it leverages several components, including:

A lexer to tokenize text streams.
A parser to process tokens based on the template language grammar.
An Abstract Syntax Tree (AST) with a visitor pattern, enabling loose coupling between evaluation, pretty printing, and other functionalities.

The Template helper class provides overloaded methods to parse and evaluate templates seamlessly, whether you’re working with strings, byte arrays, or streams.

Here’s an example of parsing and evaluating a simple template:

  var LTemplate: ITemplate := Template.Parse('hello <% _ %>');
  LOutput := Template.Eval(LTemplate, 'world');
  writeln(LOutput);

You can also load templates from a stream:

  var LStream: TStream := TBufferedFileStream.Create('hello.tpl', fmOpenRead);
  LTemplate: ITemplate := Template.Parse(LStream);
  LOutput := Template.Eval(LTemplate, 'world');
  writeln(LOutput);

While these examples demonstrate the basics, scaling this approach to manage many templates often results in different developers re-implementing the same type of solution. This is where the Template Registry shines - providing a centralized, thread-safe mechanism for managing templates efficiently.

The Template Registry assumes:

A single context contains the core configuration.
Templates are uniquely named.
Templates are loaded lazily and parsed only once.
Template access is thread-safe.

The Template Helper Class

The Template helper class includes a Resolver method and several overloaded Resolve methods for accessing templates through the registry:

type
  Template = class
    // ...

    // TEMPLATE REGISTRY

    class function Resolver(): TTemplateRegistry; static; inline;

    class procedure Resolve<T>(const ATemplateName: string; const AData: T; const AOutputStream: TStream); overload; static; inline;
    class function Resolve<T>(const ATemplateName: string; const AData: T): string; overload; static; inline;

    class procedure Resolve(const ATemplateName: string; const AOutputStream: TStream); overload; static; inline;
    class function Resolve(const ATemplateName: string): string; overload; static; inline;

    // ...
  end;

Basic Usage

Using the Template.Resolve methods simplifies template usage:

writeln(Template.Resolve('hello.tpl', 'world'));

Or, outputting directly to a stream:

var
  LStream: TStringStream := TStringStream.Create;
try
  Template.Resolve('hello.tpl', 'world', LStream);
  writeln(LStream.DataString);
finally
  LStream.Free;
end;

Load Strategy

The TTemplateRegistry.LoadStrategy property determines how templates are loaded:

type
  TTemplateLoadStrategy = (tlsLoadResource, tlsLoadFile, tlsLoadCustom);

By default:

Template.Resolver.LoadStrategy := [tlsLoadFile, tlsLoadResource];

This means the registry first attempts to load from files, falling back to resources if the file isn’t found.

Using Resources

When embedding templates as resources, naming conventions matter. Resource keys do not support slashes, so a default resolver replaces slashes (/ or \) with underscores (_). For example:

hello_tpl RCDATA "templates\\hello.tpl"

The default ResourceNameResolver transforms names:

FResourceNameResolver := function(const AName: string): string
  begin
    exit(AName.ToUpper
        .Replace('-', '_', [rfReplaceAll])
        .Replace('\', '_', [rfReplaceAll])
        .Replace('/', '_', [rfReplaceAll])
        .Replace('.', '_', [rfReplaceAll]));
  end;

Similarly, FileNameResolver adjusts paths for the target platform:

FFileNameResolver := function(const AName: string): string
  begin
    result := TPath.Combine(TemplateRootFolder, AName);
{$IFDEF MSWINDOWS}
    exit(result.Replace('/', '\'));
{$ELSE}
    exit(result.Replace('\', '/'));
{$ENDIF}
  end;

Custom Loading

For advanced use cases, templates can be loaded from external sources like databases or APIs. Add tlsLoadCustom to the load strategy:

Template.Resolver.LoadStrategy := [tlsFile, tlsLoadCustom];

Define a custom loader:

Template.Resolver.CustomTemplateLoader :=
  function(const AContext: ITemplateContext; const AName: string; const AResolveContext: TTemplateValue; out ACacheInContext: boolean): ITemplate
  begin
    // Load template from a custom source
  end;

Automatic Refresh

During development, templates can automatically refresh in debug mode:

Template.Resolver.AutomaticRefresh := true;
Template.Resolver.RefreshIntervalS := 5;

This background feature detects and reloads modified templates, ensuring changes are reflected immediately.

Conclusion

The Sempare Template Engine eliminates boilerplate and offers robust template management for Delphi developers. Its flexibility, ease of use, and advanced features, like the Template Registry, make it an indispensable tool for projects requiring dynamic text generation.

Unlike frameworks tied to specific ecosystems, the Sempare Template Engine is framework-agnostic, allowing you to use it anywhere templates are needed.

We are proud to hear from our users that the Sempare Template Engine is the most feature-rich template engine for Delphi. We hope it enhances your productivity as well.

Thank you to our supporters!

We need your help to maintain the project. Support us via GitHub Sponsors (https://github.com/sponsors/sempare) or Stripe (https://buy.stripe.com/aEU7t61N88pffQIdQQ). Sponsors gain access to exclusive features like our RAD Studio IDE wizard.

Using the ternary expression in the Sempare Template Engine for Delphi

Sempare Limited — Mon, 28 Oct 2024 13:58:51 +0000

The Sempare Template Engine (available at https://github.com/sempare/sempare-delphi-template-engine and GetIt) is a versatile templating system designed specifically for Delphi developers to streamline the creation and management of dynamic HTML, text, or any other text-based output formats. Whether you are building web applications, reports, or email templates, the Sempare Template Engine offers a powerful yet straightforward solution that integrates with minimal boilerplate into Delphi projects. The template engine has been around since 2019 and has many features for you to explore.

Sometimes, you may want an inline ternary expression to simplify more verbose if-expressions.

e.g. You may have something like:

<% x := 123 %>
<% if x > 100 %>
   a big value
<% else %>
   a low value
<% end %>

We could convert the above into:

<% x := 123 %>
<% print('a big value' if x > 100 else 'a low value') %>

Conclusion

The above tutorial illustrated how a ternary expression could

The Sempare Template Engine is very flexible, configurable and extensible, allowing for a good seperation of concerns between your business logic that will access data, and the templating engine that will render/present your data as required.

The template engine is available on https://github.com/sempare/sempare-delphi-template-engine and via Embarcadero GetIt.

Sponsorship Required

Please help us maintain the project by supporting Sempare via GitHub sponsors (https://github.com/sponsors/sempare) or via our payment link (https://buy.stripe.com/aEU7t61N88pffQIdQQ). Sponsors can obtain access to our integrated IDE wizard for RAD Studio.

Eliminating whitespace in Sempare Template Engine for Delphi templates

Sempare Limited — Thu, 24 Oct 2024 18:19:24 +0000

The Sempare Template Engine (available at https://github.com/sempare/sempare-delphi-template-engine and GetIt) is a versatile templating system designed specifically for Delphi developers to streamline the creation and management of dynamic HTML, text, or any other text-based output formats. Whether you are building web applications, reports, or email templates, the Sempare Template Engine offers a powerful yet straightforward solution that integrates with minimal boilerplate into Delphi projects. The template engine has been around since 2019 and has many features for you to explore.

In this tutorial, we will illustrate how whitespace (space and newlines) can be eliminated from templates managed by the Sempare Template Engine.

Typically, when using templates, there may be more whitespace and newlines in a template that you really want. Let's explore a few options.

<% ignorews %>
  no more spaces
<% end %>

This template will result in:

nomorespaces

Similarly, there is:

<% ignorenl %>
this.
is.
a.
test.
<% end %>

This will result in:

this.is.a.test.

These are a bit crude.

When it comes to the normal statements, we have a better alternative that you can simply add a - immediately after the script open tag.

    <%- if true %>
    this will be displayed
    <% else %>
    this won't
    <% end %>

This will result in:

    this will be displayed

The behaviour of the <%- is as follows:

the whitesapce before the '<%-' will be removed
the whitespace including the newline after true '%>' will be removed
the whitespace before and after, including newline around <% else %> will be removed
the whitespace before and after, including newline around <% end %> will be removed

Nested statements will need to have the hint applied as well.

    <ul>
    <%- for x := 1 to 3 %>
       <%- y := x + 1 %>
       <li><%- y %></li>
    <% end %>
    </ul>

Without the hints, you will see output like:

    <ul>


      <li>2</li>

      <li>3</li>

      <li>4</li>


    </ul>

With the hint, we will get a cleaner output:

    <ul>
      <li>2</li>
      <li>3</li>
      <li>4</li>
    </ul>

Conclusion

In summary, the template engine provides a few alternatives to help minimise the whitespace generated by templates.

The template engine is available on https://github.com/sempare/sempare-delphi-template-engine and via Embarcadero GetIt.

Sponsorship Required

Creating helper functions for the Sempare Template Engine

Sempare Limited — Thu, 17 Oct 2024 13:24:44 +0000

The Sempare Template Engine (available at https://github.com/sempare/sempare-delphi-template-engine and GetIt) is a versatile templating system designed specifically for Delphi developers to streamline the creation and management of dynamic HTML, text, or any other text-based output formats. Whether you are building web applications, reports, or email templates, the Sempare Template Engine offers a powerful yet straightforward solution that integrates with minimal boilerplate into Delphi projects. The template engine has been around since 2019 and has many features for you to explore.

In this tutorial, we will explore how to add helper functions to the template engine.

Builtin functions

The template engine has a number of builtin functions as described on https://github.com/sempare/sempare-delphi-template-engine/blob/main/docs/builtin-functions.md

In this tutorial, we will describe you you can use your own.

Calling functions

Lets start by illustrating how to call a builtin function:

<% fmtdt('yyyy-mm-dd', dtnow()) %>

Calling a custom helper function is no different, except that the builtin functions have been pre-packaged.

Defining functions

Defining functions is done by defining static class methods on a class and binding them to a context.

type
  THelperMethods = class
  public
    class function Add(const AValue, BValue : integer) : integer; static;
  end;

class function THelperMethods.Add(const AValue, BValue : integer) : integer;
begin
  Result := AValue + BValue;
end;

The nice thing about Delphi's RTTI system is that we can map the parameters provided to to the template to the methods using normal types, rather than variadic alternatives and utilising the type system available to us.

Accessing context information

If your function requires access to the template context, it may be presented as the first parameter.

   class function DoSomething(const AContext: ITemplateContext; const AValue : string) : string; static;

Registering your functions

Registering your functions is done through a Template Context and accessing it is a simple as illustrated:

var LContext := Template.Context();
LContext.Functions.AddFunctions(THelperMethods);

var LOutput := Template.Eval(LContext, '<% Add(1,2) %>');

writeln(LOutput);

Limitations

Support for overloaded methods is not robust at present. We do have a patch on the way to improve overloaded support, but it is heavier on the system, so would rather advise having methods with unique names that are not overloaded.

Support for variadic parameters is also going to be improved. e.g. a signature such as:

   class function Sum(const AValues : TArray<integer>) : integer; static;

Lastly, the template engine has no context of default parameters on methods. Unfortunately, you will have to ensure all parameters are passed through correctly.

Conclusion

The Sempare Template Engine offers you many options to extend and offer richness to your templates.

Sponsorship Required

Accessing a FireDAC dataset from the Sempare Template Engine for Delphi

Sempare Limited — Thu, 17 Oct 2024 11:32:37 +0000

The Sempare Template Engine (available at https://github.com/sempare/sempare-delphi-template-engine and GetIt) is a versatile templating system designed specifically for Delphi developers to streamline the creation and management of dynamic HTML, text, or any other text-based output formats. Whether you are building web applications, reports, or email templates, the Sempare Template Engine offers a powerful yet straightforward solution that integrates with minimal boilerplate into Delphi projects. The template engine has been around since 2019 and has many features for you to explore.

In this article, we will explore how a FireDAC TDataSet can be enumerated from a Sempare Template Engine template.

The code for this tutorial is available at https://github.com/sempare/sempare-devto-examples/tree/dev/FireDACInMemory

Creating a mock dataset

We normally get a TDataSet back from a database query. In this tutorial, I'll construct a TFDMemTable which we can use later in a template.

function CreateMockUsersTable(): TFDMemTable; 

    procedure AddPerson(const AName: string; const AAge, AWeight: integer);
    begin
      result.Append;
      result.FieldByName('name').value := AName;
      result.FieldByName('age').value := AAge;
      result.FieldByName('weight').value := AWeight;
      result.Post;
    end;

begin
  result := TFDMemTable.Create(nil);
  result.FieldDefs.Add('name', ftWideString, 20);
  result.FieldDefs.Add('age', ftInteger);
  result.FieldDefs.Add('weight', ftFloat);
  result.CreateDataSet;
  AddPerson('joe', 20, 67);
  AddPerson('pete', 19, 87);
  AddPerson('jane', 23, 47); 
end;

In the function above, we create a TFDMemTable containing 3 users. We first define the fields and then add the users.

templates/users.tpl

<h1>Users</h1>
<% for idx in Users %>
      <tr>
         <td><% idx %></td>
         <td><% Users.name %></td>
         <td><% Users.age %></td>
         <td><% Users.weight %></td>
      </tr>
  <% onbegin %>
    <table>
      <tr>
         <th>No</th>
         <th>Name</th>
         <th>Age</th>
         <th>Width</th>
      </tr>
  <% onend %>
    </table>
  <% onempty %>
    <div>There are no users</div>
<% end %>

In the above template, we use some of the additional 'events' on loops to control various aspects around when the header, body and footer is created, as well as what to output when there is no data. During each iteration, the the loop will dereference the various fields from the dataset, as we see with 'Users.name' as an example.

Now to pull it all together:

program FireDACInMemoryExample;

uses
  Data.DB,
  FireDAC.Comp.Client,
  System.SysUtils,
  Sempare.Template;

function CreateMockUsersTable(): TFDMemTable; 
begin 
  // code from above
end;

type
  TTemplateData = record
    Users: TDataSet;
  end;

var
  LTemplateData : TTemplateData;
begin
  LTemplateData.Users := CreateMockUsersTable;
  try
    writeln(Template.Resolve('users.tpl', LTemplateData)); 
  finally
    LTemplateData.Users.Free;
  end;
end.

This will give us a simple HTML table:

    <h1>Users</h1>
    <table>
      <tr>
         <th>No</th>
         <th>Name</th>
         <th>Age</th>
         <th>Width</th>
      </tr>
      <tr>
         <td>1</td>
         <td>joe</td>
         <td>20</td>
         <td>67</td>
      </tr>
      <tr>
         <td>2</td>
         <td>pete</td>
         <td>19</td>
         <td>87</td>
      </tr>
      <tr>
         <td>3</td>
         <td>jane</td>
         <td>23</td>
         <td>47</td>
      </tr>
    </table>

Gotchas

Something to be aware of. When enumerating using the for statement, the index variable returns an offset into the data set, starting from 1.

We dereference fields directory off the dataset as shown above. If there are spaces in the field name, you can use array dereferencing style. e.g. In the above Users.name and Users['name'] are equivalent.

Conclusion

The above example has illustrated how a simple HTML report can be generated with an in memory FireDAC table.

The template engine is available on https://github.com/sempare/sempare-delphi-template-engine and via Embarcadero GetIt.

Sponsorship Required

Introducing the Sempare Template Engine Playground Wizard for the Delphi RAD Studio IDE

Sempare Limited — Wed, 16 Oct 2024 23:12:37 +0000

The Sempare Template Engine (available at https://github.com/sempare/sempare-delphi-template-engine and GetIt) is a versatile templating system designed specifically for Delphi developers to streamline the creation and management of dynamic HTML, text, or any other text-based output formats. Whether you are building web applications, reports, or email templates, the Sempare Template Engine offers a powerful yet straightforward solution that integrates with minimal boilerplate into Delphi projects. The template engine has been around since 2019 and has many features for you to explore.

In this article, I’m excited to present a preview of the Sempare Template Engine Playground Wizard for the Delphi IDE. This tool enables developers to work with templates using mock data, eliminating the need for a running application or server.

Recently, we transitioned the licensing of the Sempare Template Engine from GPL to a dual-license model under the Apache 2.0 and the Sempare Commercial License.

Unlike some competitors, we’ve had limited financial backing to support our R&D efforts, relying primarily on our own resources. While other templating products may not necessarily offer more features, increased competition has made it necessary for us to expand our user base. However, there’s a growing expectation for free tools, despite the common understanding that, while we have freedom of speech, there’s no such thing as free beer when it comes to Open Source.

As a result, we’ve decided that the IDE integration will be available to our commercial supporters once it is finalized.

Demo using the Horse framework

Horse (https://github.com/HashLoad/horse) is a small webframework based on the Indy Project (https://www.indyproject.org). I won't go into the details of installing the framework as this can be done easily through GetIt or from GitHub. Indy should be available with the RAD Studio.

The source for this demo is available on https://github.com/sempare/sempare-devto-examples/tree/dev/HorseDemo

HorseDemo.dpr

program HorseDemo;

{$APPTYPE CONSOLE}
{$R *.res}

uses
  Horse,
  Sempare.Template,
  System.SysUtils;

type
  TIndexData = record
    Name: string;
    Users: TArray<string>;
  end;

begin
  try
    THorseProvider.KeepConnectionAlive := true;
    THorse.Get('/',
      procedure(Req: THorseRequest; Res: THorseResponse)
      var
        LData: TIndexData;
      begin
        LData.Name := 'Sempare Template Engine';
        Res.Send(Template.Resolve('index', LData));
      end);
    THorse.Get('/page2',
      procedure(Req: THorseRequest; Res: THorseResponse)
      var
        LData: TIndexData;
      begin
        LData.Name := 'Sempare Template Engine';
        LData.Users := ['Ian', 'Macro', 'David'];
        Res.Send(Template.Resolve('page2', LData));
      end);
    THorse.Listen(8080, nil,
      procedure
      begin
        TTemplateRegistry.Finalize;
      end);
  except
    on E: Exception do
      Writeln(E.ClassName, ': ', E.Message);
  end;
end.

Above we can see in a few lines of code we have created a small web server running on port 8080, exposing endpoints / and /page2.

Below are some templates for the demo. We describe the template constructs in some of the other tutorials. These are just for reference for now, as we want you to see the IDE integration below.

templates/index.tpl

<% extends 'layout' %>
   <% block 'header' %><title>Index</title><% end %>
   <% block 'body' %>This is the index page <% end %>
<% end %>

templates/page2.tpl

<% extends 'layout' %>
   <% block 'header' %><title>Page2</title><% end %>
   <% block 'body' %>
     <% for user of users ; user ; betweenitems %>, <% end %>
   <% end %>
<% end %>

templates/layout.tpl

<html>
  <header>
        <style>
            body { background: #333333 ; color: #ffffff }
            <% block 'style' ; end %>
        </style>
        <% block 'header' ; end %>
  </header>
  <body>
        <% block 'body' %>Default Content<% end %>
  </body>
</html>

Preview the layout

In the bottom panel, we can see a docked panel containing 3 sections:

mock data editor
template editor
preview (raw text and html)

In the preview, we can see the layout being rendered.

Preview the index page

Here we can see that the body placeholder is being replaced in the layout.

Preview page2

Here we see the header placeholder being filled with an HTML title. In the body, we have our mock data being rendered.

Preview page 2 with one user

Preview page 2 with no users

Errors are instantly highlighted

In the above screenshot, we can see how removing the > on line 5 yields the error message.

Running the demo and opening Page2 in Edge

Pressing F9 and running the app, we are in a position to launch Edge and open http://localhost:8080/page2. Note the output matches the mock data with users.

Conclusion

While Delphi hasn’t historically been a common choice for web development, the availability of more tools and libraries is making it a viable option for such projects. As a dialect of Pascal, one of Delphi’s strengths is its compiler, which generates cross-platform native code (Linux, Windows, Android, macOS, iOS). The language is type-safe, classified as memory safe, and highly approachable for new users, with language features that are intuitive and easy to grasp without extensive manual reading—though diving into the documentation can unlock even more advanced capabilities.

This is still in the early stages of development, but with additional commercial sponsorship, we aim to further evolve this wizard and continue supporting the underlying project.

Thank you in advance for your support.

Configuring the Sempare Template Engine for Delphi

Sempare Limited — Wed, 16 Oct 2024 23:12:11 +0000

The Sempare Template Engine (available at https://github.com/sempare/sempare-delphi-template-engine and GetIt) is a versatile templating system designed specifically for Delphi developers to streamline the creation and management of dynamic HTML, text, or any other text-based output formats. Whether you are building web applications, reports, or email templates, the Sempare Template Engine offers a powerful yet straightforward solution that integrates with minimal boilerplate into Delphi projects. The template engine has been around since 2019 and has many features for you to explore.

In this tutorial, we will explore some of the options to configure a template context.

Safe web development

We know we are in an unsafe world! Attacks are occurring continually. SQL injection, HTML injection just to name the most obvious...

The Sempare Template Engine has features to ensure your web app is safe and responsive. Two features that are important are:

max run times
automatic HTML encoding

Max run times

By default, the max runtime is set to 1 minute.

This can be customised:

  var ctx := Template.Context();
  ctx.MaxRunTimeMs = 5;

Automatic HTML encoding

This can be customised:

var LCtx := Template.Context();
LCtx.UseHtmlVariableEncoder();

Let's say we have the following scenario:

type
   TTemplateData = record
      DataField : string;
   end;

var LData : TTemplateData;
LData.DataField := '<script>alert("hello world");</script>';

writeln(Template.Eval('Unsafe: <% DataField %>', LData));
writeln(Template.Eval(LCtx, 'Safe: <% DataField %>', LData));

The output:

Unsafe: <script>alert("hello world");</script>
Safe: &lt;script&gt;alert(&quot;hello world&quot;);&lt;/script&gt;

When you have HTML encoding enabled, you may have scenarios where you want to evaluate raw HTML. You can use the print statement to do this.

<% DataField %>
     vs
<% print(DataField) %>

Changing the script tags

By default, template scripting is done between the <% and %> tags.

This can be changed as follows:

  var LCtx := Template.Context();
  LCtx.StartToken := '{{';
  LCtx.EndToken := '}}';
  writeln(Template.Eval(LCtx, '{{ if true }}hello{{else}}bye{{end}}'));

Embedded error messages

By default, errors in the template evaluation results in a template Exception being raised.

try
  writeln(Template.Eval(LCtx, '<% a := ["a"; "b"] %>'));
except on E: Exception do
  writeln(E.Message);
end;

The above example will raise an exception stating that a comma (,) is expected, rather than the semicolon (;).

We can change the behaviour as follows:

var LCtx := Template.Context();
LCtx.Options := LCtx.Options + [eoEmbedException];
try
  writeln(Template.Eval(LCtx, '<% a := ["a"; "b"] %>'));
except on E: Exception do
  writeln(E.Message);
end;

The above example will produce output:

(Line 1, Column 14) Parsing error. Expecting: ,

Documentation

The documentation for the context is available at https://github.com/sempare/sempare-delphi-template-engine/blob/main/docs/configuration.md

Conclusion

There are many configuration options available for manipulating the behaviour of the template engine.

Sponsorship Required

Functional templates with the Sempare Template Engine for Delphi

Sempare Limited — Wed, 16 Oct 2024 23:10:58 +0000

The Sempare Template Engine (available at https://github.com/sempare/sempare-delphi-template-engine and GetIt) is a versatile templating system designed specifically for Delphi developers to streamline the creation and management of dynamic HTML, text, or any other text-based output formats. Whether you are building web applications, reports, or email templates, the Sempare Template Engine offers a powerful yet straightforward solution that integrates with minimal boilerplate into Delphi projects. The template engine has been around since 2019 and has many features for you to explore.

In this tutorial, we will explore how templates can behave like functions and all the super powers of 'include'.

The basics

We can define inline templates and use them as follows:

<% template 'person' %>
   <div>
      <div><% name %></div>
   </div>
<% end %>

<%# this is a comment %>

<%# we can define dictionaries in the script tags %>

<% people := [
     { "name": "conrad" },
     { "name": "ian" },
     { "name": "richard" }
   ]
%>

<% for person of people %>
   <% include 'person', person %>
<% end %>

In the above, we define a template name 'person' - containing some HTML div tags.

Then we have a for loop enumerating over the people array. Using the inline data is useful when mocking data, as we can test it without having a server running, either using the demo Playground app, or using the IDE Wizard which will be discussed in another tutorial.

What are functional templates?

As we have seen, the 'include' statement behaves like a function. However, there is an alternative syntax for including templates, which makes it appear more functional. Let us illustrate:

<% for person of people %>
   <% person { name=person.name } %>
<% end %>

Lets try something different to illustrate it:

<% template 'input' %>
   <div>
      <div><% label %>:</div>
      <input id="<% id %>" <% if name %>name="<% name %>"<% end %>>
   </div>
<% end %>

  <form method="post" action="/signup">
    <% input { label="First Name", id="firstname", name="fn" } %>
    <% input { label="Last Name", id="lastname", name="ln" } %>
    <% input { label="E-mail", id="email", name="email" } %>
    <input type="submit"> 
  </form>

Note that the 'functional include' syntax is slightly different to the dictionary format illustrated above with the mock data.

Why is this interesting? Maybe Atomic Design?

Lets say you like styling with TailwindCSS (https://tailwindcss.com). We can create a template library, either standalone or inline, with 'atomic' components that we can define with whatever granularity we require. We can build up more complex components by including others as required.

We can build styled templates for buttons, inputs, grids, etc.

Conclusion

The Sempare Template Engine offers a lot of rich functionality, allowing you to manipulate text output to fit your needs.

Creating layouts using the Sempare Template Engine for Delphi

Sempare Limited — Wed, 16 Oct 2024 23:07:37 +0000

The Sempare Template Engine (available at https://github.com/sempare/sempare-delphi-template-engine and GetIt) is a versatile templating system designed specifically for Delphi developers to streamline the creation and management of dynamic HTML, text, or any other text-based output formats. Whether you are building web applications, reports, or email templates, the Sempare Template Engine offers a powerful yet straightforward solution that integrates with minimal boilerplate into Delphi projects. The template engine has been around since 2019 and has many features for you to explore.

In this tutorial, we will explore how layouts can be created using the Sempare Template Engine.

This can be done in different ways, depending on the requirements:

use 'include' statements
use 'extends' and 'block' statements

In the examples below, we will assume we are working on server side rendering of HTML pages.

Using include statements

Using include statements can be used for layouts, but doesn't scale very well. We will investigate the include statement in another tutorial as it has some super powers. For now, lets say we have an index page. We know there is a header, body and footer. A simple approach is as follows:

header.tpl

<html>
   <header>
   </header>
   <body>

footer.tpl

   </body>
</html>

index.tpl

<% include 'header' %>
   This is my index page
<% include 'footer' %>

In the above, you will note that it may be more complex to manage the layout consistently. We will consider an improved approach in the next section.

Creating a layout

Considering you may be doing server side rendering, we can create a layout.tpl:

<html>
   <header>
      <style>
         <% block 'style'; end %>
      </style>
      <% block 'header'; end %>
   </header>
   <body>
      <% block 'body' %>Default Content<% end %>
   </body>
</html>

The nice thing about the above approach is that we get a good sense of the template above compared to the 'include' approach. Placeholders named style, header and body are defined. The body placeholder block has default content, where the others are empty.

Now we could have an index.tpl:

<% extends 'layout' %>
   <% block 'header %>
       <title>Index</title>
   <% end %>
   <% block 'body' %>
      This is the index page.
   <% end %>
<% end %>

So the above will reference the layout template and replace the header and body placeholder blocks with the content in this template.

Managing state and layout from your code

Now lets say you have two different layouts, one for being an anonymous user, and another for being a signed in user.

Our template could reference the layout via a variable such as:

<% extends layoutTpl %>
   <% block 'header %>
       <title>Index</title>
   <% end %>
   <% block 'body' %>
      This is the index page.
   <% end %>
<% end %>

We may have Delphi/Object Pascal that uses a structure such as:

type
  TIndexData = record
     LayoutTpl : string;
  end;

function GetIndexData() : TIndexData;
begin
   if SignedIn then
     result.LayoutTpl := 'layout_authenticaetd.tpl'
   else
     result.LayoutTpl := 'layout_guest.tpl';
end;

Controlling the layout can be done in the same way we return data to the template engine.

Conclusion

The Sempare Template Engine offers flexibility in the way layouts can be managed, allowing you to maintain your output according to your needs.

Sponsorship Required

Using loops in the Sempare Template Engine for Delphi

Sempare Limited — Wed, 16 Oct 2024 23:07:15 +0000

The Sempare Template Engine (available at https://github.com/sempare/sempare-delphi-template-engine and GetIt) is a versatile templating system designed specifically for Delphi developers to streamline the creation and management of dynamic HTML, text, or any other text-based output formats. Whether you are building web applications, reports, or email templates, the Sempare Template Engine offers a powerful yet straightforward solution that integrates with minimal boilerplate into Delphi projects. The template engine has been around since 2019 and has many features for you to explore.

In this tutorial we will review some of the looping statements, namely for and while.

Basic for loops

The basics, as we do in pascal, we can loop over a fixed range:

   <table>
   <% for i := 1 to 10 %>
     <tr><td><% i %></td><tr>
   <% end %>
   </table>

This will produce the output:

  <table>
     <tr><td>1</td></tr>
     <tr><td>2</td></tr>
     ... 3 to 8 ommitted ...
     <tr><td>9</td></tr>
     <tr><td>10</td></tr>
  </ul>

Lets make it more interesting, and use variables:

   <% start_idx := 1; end_idx := 10 %>
   <table>
   <% for i := start_idx to end_idx %>
     <tr><td><% i %></td></tr>
   <% end %>
   </table>

Let us assume the variables are driven by user input, rather than being set in the template. Now we need to also cater for the scenario that no values are present. So we could devise a script like:

   <% if (start_idx >= 0) and (end_idx > 0) %>
     <table>
     <% for i := start_idx to end_idx %>
       <tr><td><% i %></td></tr>
     <% end %>
     </table>
   <% else %>
     <p>There are no values</p>
   <% end %>

This could be translated to the following using extension to the for loop grammar:

     <% for i := start_idx to end_idx %>
         <tr><td><% i %></td></tr>
       <% onbegin %>
         <table>
       <% onend %>
         </table>
       <% onempty %>
        <p>There are no values</p>
     <% end %>

Enumerable for loops

For loops are flexible and can enumerate over different structures such as arrays, lists, dictionaries, JSON arrays, and can be extended to enumerate over custom types as well.

When it comes to enumeration, there are also two variations of the for loop, namely 'for in' and 'for of'. Lets have a quick look at some examples:

<% arr := [ 5, 4, 3, 2, 1 ] %>
<% for i in arr ; i ; betweenitems %>, <% end %>

This will output:

0, 1, 2, 3, 4, 5

This is very similar to JavaScript behaviour.

<% arr := [ 5, 4, 3, 2, 1 ] %>
<% for i of arr ; i ; betweenitems %>, <% end %>

This will yield:

5, 4, 3, 2, 1

Looping over dictionaries

Assume we have the following:

type
   TPerson = record
     Name: string;
   end;
var LUsers : TDictionary<string, TPerson>;
var LTemplate:string := '...'; // listed below
//
writeln(Template.Eval(LTemplate, LUsers));

the template:

<% for email in _ %>
  Email: <% email %> Name: <% _[email].Name %> 
<% end %>

The magic _ references the TDictionary passed to the template.

Consider we may only be interested in the names, we could change the template to:

<% for person of _ %>
  Name: <% person.Name %> 
<% end %>

More documentation is available at: https://github.com/sempare/sempare-delphi-template-engine/blob/main/docs/statements.md#for

While loops

A while statement is a loop based on a condition being true.

   <% i := 0; while i < 10; i; betweenitems %>, <% end %>

Breaking out of a loop

As in Pascal, we can use the break statement to break out of a for or while loop.

   <% for i := 1 to 10 %>
      <% if i = 5 ; break ; end %>
      <% i %>
   <% end %>

The above will show the values 1 to 4.

More documentation is available at: https://github.com/sempare/sempare-delphi-template-engine/blob/main/docs/statements.md#while

Skipping iterations

Similar to the above, we can use the continue statement to skip iterations in for or while loops.

   <% for i := 1 to 10 %>
      <% if i mod 2 == 0 ; continue ; end %>
      <% i %>
   <% end %>

The above will show all the odd numbers.

Conclusion

The Sempare Template Engine offers a lot of rich functionality, allowing you to manipulate text output to fit your needs.

Sponsorship Required

Accessing data from the Sempare Template Engine for Delphi

Sempare Limited — Wed, 16 Oct 2024 23:05:45 +0000

The Sempare Template Engine (available at https://github.com/sempare/sempare-delphi-template-engine and GetIt) is a versatile templating system designed specifically for Delphi developers to streamline the creation and management of dynamic HTML, text, or any other text-based output formats. Whether you are building web applications, reports, or email templates, the Sempare Template Engine offers a powerful yet straightforward solution that integrates with minimal boilerplate into Delphi projects. The template engine has been around since 2019 and has many features for you to explore.

In this tutorial we will explore the various ways in which data can be accessed by Sempare Template Engine templates.

Overview

The template engine provides numerous ways for data to be accessed:

Data passed to the template
Data passed upfront in the context
Data queried on demand
Data queried by static helper functions
Data queried by helper methods

This tutorial assumes you have installed the template engine following the instructions discussed elsewhere.

Let us explore each of these approaches.

Data passed to the template

This is the simplest approach where we pass data while evaluating the template.

program test;

uses
  Sempare.Template;

type
  TTemplateData = record
    Name : string;
  end;

var
  LData: TTemplateData;
  LTemplate : ITemplate;
begin
  LData.Name := 'Joe';
  LTemplate := Template.Parse('Hello <% name %>');
  writeln(Template.Eval(LTemplate, LData));
end;

Data passed upfront in the context

By default, the Template helper methods will create a new context if you do not provide one. A context allows us to provide bespoke configuration that changes the way the template engine behaves. We can use this to also store global variables.

program test;

uses
  Sempare.Template;
var 
  LContext: ITemplateContext;
  LTemplate : ITemplate;
begin
  LContext := Template.Context();
  LContext.Variable['Company'] := 'Sempare Limited';
  LContext.Variable['CopyrightYear'] := 2024;
  LTemplate := Template.Parse('Copyright <% Company %>, <% CopyrightYear %>');
  writeln(Template.Eval(LContext, LTemplate, LData));
end;

Data queried on demand

Rather than injecting values into the context, we can provide an anonymous function that allows for values to be resolved.

program test;

uses
  Sempare.Template;
var 
  LContext: ITemplateContext;
  LTemplate : ITemplate;
begin
  LContext := Template.Context();
  LContext.VariableResolver := function(const AContext: ITemplateContext; const AName: string; out AResult: TValue): boolean
    begin
      if AName = 'Company' then
      begin
        AResult := 'Sempare Limited';
        exit(true);
      end;
      if AName = 'CopyrightYear' then
      begin
        AResult := 2024;
        exit(true);
      end;
      AResult := '';
      exit(false);
    end;
  LTemplate := Template.Parse('Copyright <% Company %>, <% CopyrightYear %>');
  writeln(Template.Eval(LContext, LTemplate, LData));
end;

Above, the resolver must return true if it is able to find the result. The AResult is a TValue from the RTTI unit which can store anything.

Note that if you allocate memory, you must deallocate memory yourself after the template has been evaluated.

Data queried by static helper functions

program test;

uses
  Sempare.Template;

type
  THelperMethods = class
    class function GetCompany() : string; static;
    class function GetCopyrightYear() : integer; static;
  end;

class function THelperMethods.GetCompany() : string;  
begin
  exit('Sempare Limited');
end;

class function THelperMethods.GetCopyrightYear() : integer; 
begin
  exit(2024);
end;

var 
  LContext: ITemplateContext;
  LTemplate : ITemplate;
begin
  LContext := Template.Context();
  LContext.Functions.AddFunctions(THelperMethods);
  LTemplate := Template.Parse('Copyright <% GetCompany() %>, <% GetCopyrightYear() %>');
  writeln(Template.Eval(LContext, LTemplate, LData));
end;

In the above, we have illustrated how we add static functions and procedures.

Data queried by helper methods

program test;

uses
  Sempare.Template;

type
  TCompanyInfo = class
    function GetCompany() : string; 
    function GetCopyrightYear() : integer; 
    property Company: string read GetCompany;
    property CopyrightYear: integer read GetCopyrightYear;
  end;

function TCompanyInfo.GetCompany() : string;  
begin
  exit('Sempare Limited');
end;

function TCompanyInfo.GetCopyrightYear() : integer; 
begin
  exit(2024);
end;

var 
  LCompanyInfo : TCompanyInfo;
  LContext: ITemplateContext;
  LTemplate : ITemplate;
begin
  LCompanyInfo := TCompanyInfo.Create;
  try
    LContext := Template.Context();
    LContext.Variables['company'] := LCompanyInfo;
    LTemplate := Template.Parse('Copyright <% _.Company %>, <% _.CopyrightYear %>');
    writeln(Template.Eval(LContext, LTemplate, LData));
  finally
    LCompanyInfo.Free;
  end;
end;

In the above, we also use '_' which is a magic variable that is an alias for the data being passed into the template.

Conclusion

As we have seen above, the Sempare Template Engine is very flexible and allows you to access data in many ways, allowing you to use it according to your usage pattern.

Sponsorship Required

DEV Community: Sempare Limited

Building Ultra-Lightweight Docker Images with Free Pascal: From Scratch in just over 1MB! 🚀

Why This Matters

The Magic: Docker's scratch Image

The Setup

The Multi-Stage Dockerfile

Building and Testing

Why This is So Cool

Free Pascal Advantages

Comparison with Other Languages

Real-World Applications

Tips for Success

Conclusion

Thank you to our supporters!

The Sempare Template Engine for Delphi: Advanced Template Registry Features

Introduction: Why Use a Template Registry?

The Template Helper Class

Basic Usage

Load Strategy

Using Resources

Custom Loading

Automatic Refresh

Conclusion

Thank you to our supporters!

Using the ternary expression in the Sempare Template Engine for Delphi

Conclusion

Eliminating whitespace in Sempare Template Engine for Delphi templates

Conclusion

Creating helper functions for the Sempare Template Engine

Builtin functions

Calling functions

Defining functions

Accessing context information

Registering your functions

Limitations

Conclusion

Accessing a FireDAC dataset from the Sempare Template Engine for Delphi

Creating a mock dataset

Gotchas

Conclusion

Introducing the Sempare Template Engine Playground Wizard for the Delphi RAD Studio IDE

Demo using the Horse framework

Preview the layout

Preview the index page

Preview page2

Preview page 2 with one user

Preview page 2 with no users

Errors are instantly highlighted

Running the demo and opening Page2 in Edge

Conclusion

Further reading

Configuring the Sempare Template Engine for Delphi

Safe web development

Max run times

Automatic HTML encoding

Changing the script tags

Embedded error messages

Documentation

Functional templates with the Sempare Template Engine for Delphi

The basics

What are functional templates?

Why is this interesting? Maybe Atomic Design?

Conclusion

Further reading

Creating layouts using the Sempare Template Engine for Delphi

Using include statements

Creating a layout

Managing state and layout from your code

Conclusion

Using loops in the Sempare Template Engine for Delphi

Basic for loops

Enumerable for loops

Looping over dictionaries

While loops

Breaking out of a loop

Skipping iterations

Conclusion

Accessing data from the Sempare Template Engine for Delphi

Overview

Conclusion

The Magic: Docker's `scratch` Image