2026-04-02·8 min read·sota.io team

Deploy Free Pascal to Europe — Niklaus Wirth 🇨🇭 + Anders Hejlsberg 🇩🇰 Pascal Heritage on EU Infrastructure in 2026

In 1983, a 23-year-old Danish programmer named Anders Hejlsberg wrote a Pascal compiler from scratch, in assembly language, in Copenhagen. Borland sold it for $49.95. Turbo Pascal 1.0 compiled programs in seconds — ten to fifty times faster than the competing CP/M compilers of the time. It ran on the new IBM PC, it shipped with an integrated editor, and it made programming accessible to a generation of European software engineers who could not afford expensive mainframe tooling. Anders Hejlsberg would go on to create Delphi, then C# at Microsoft, then TypeScript — but Turbo Pascal was where he invented the fast compiler loop that shaped modern software development.

The language that Turbo Pascal implemented was Pascal, created by Niklaus Wirth 🇨🇭 at ETH Zürich in 1970. Wirth designed Pascal as a teaching language to demonstrate structured programming — programs composed of clear control structures, not GOTO statements. He wanted a language where the structure of the code reflected the structure of the problem. Pascal became the dominant teaching language of European computer science departments throughout the 1970s and 1980s. Wirth received the Turing Award in 1984. He spent his entire career at ETH Zürich.

Free Pascal (FPC) is the production-ready open-source continuation of this tradition. It was started in 1993 by Florian Klämpfl 🇩🇪 in Germany and has been maintained by a European-majority team ever since. Free Pascal compiles Object Pascal — the same language as Delphi — to native binaries for Linux, Windows, macOS, ARM, and RISC-V. It is how thousands of European enterprises maintain and extend their Delphi-era codebases on modern infrastructure. It is how new Pascal code gets written today.

Niklaus Wirth and Structured Programming at ETH Zürich

Niklaus Wirth 🇨🇭 was born in Winterthur, Switzerland in 1934. He studied at ETH Zürich, received his PhD from the University of California at Berkeley in 1963, and returned to ETH as a professor in 1968, where he remained until his retirement in 1999. He died in January 2024 at age 89, at his home near Zürich.

Wirth designed Pascal between 1968 and 1970. The language was a response to the complexity of ALGOL 68 — which was powerful but too complicated — and to the unstructured programming habits encouraged by languages like FORTRAN and BASIC. Pascal enforced structured control flow: if-then-else, while, for, repeat-until, case. Programs had a clear top-down structure: constants, types, variables, and procedures declared in order, a main program that called them. Data types were strict and checked at compile time. The compiler could reject incorrect programs without running them.

The immediate practical result was that Pascal programs were easier to read, easier to teach, and easier to verify than FORTRAN programs. By the mid-1970s, Pascal had become the primary teaching language at ETH and was spreading to universities across Europe and North America. The UCSD Pascal system, Borland Turbo Pascal, and Apple's first Pascal compiler were all built on Wirth's design.

Wirth did not stop at Pascal. He went on to create Modula (1975), Modula-2 (1978), and Oberon (1987) — each a refinement of Pascal's ideas. Oberon removed features, simplified the language, and added modules as the primary unit of compilation. The Go programming language's module system traces direct influence from Wirth's module design. His principle was consistent across all these languages: simplicity is not the absence of power, but the absence of unnecessary complexity.

Anders Hejlsberg and the Turbo Pascal Revolution

Anders Hejlsberg 🇩🇰 was born in Copenhagen in 1960. He grew up programming on a Xerox 820 and a Poly-88. In 1980, at age 20, he wrote a Pascal compiler in assembler for the Nascom 2 microcomputer. By 1982 he had moved to Borland International, where he spent the next decade.

Turbo Pascal 1.0, released in November 1983 for CP/M, was priced at $49.95 when competing Pascal compilers cost $400-1000 and ran on mainframes. It included an integrated editor — you wrote and compiled from the same screen. The compilation was fast because Hejlsberg's one-pass compiler read the source code once and generated code immediately, without building an intermediate representation. Programs that took minutes to compile elsewhere compiled in seconds.

Turbo Pascal ran on the IBM PC, which was rapidly penetrating European offices and universities. The combination of low price, high speed, and the integrated development experience made Turbo Pascal the standard for a generation of European developers. Germany, France, the Netherlands, and the Scandinavian countries saw entire software industries built on it. German accounting software, Dutch control systems, Danish business applications — the 1980s enterprise software that still runs in EU companies today was frequently written in Turbo Pascal or its Object Pascal successor.

In 1995, Hejlsberg designed Delphi — the Object Pascal RAD (Rapid Application Development) environment that added visual component design and a class library to Turbo Pascal's compilation model. Delphi defined enterprise development in Europe through the late 1990s and 2000s. He then joined Microsoft in 1996, where he designed C# (2000) and TypeScript (2012). The clean type system, the fast compilation, and the IDE integration that Hejlsberg brought to C# and TypeScript originate directly in what he built at Borland.

Free Pascal — The European Open Source Continuation

Florian Klämpfl 🇩🇪 began writing Free Pascal in 1993 while studying at the University of Erlangen-Nuremberg in Germany. The motivation was straightforward: he wanted a free Pascal compiler for his 386 PC that was compatible with Turbo Pascal. The first release supported DOS and produced 386 protected-mode code. By the late 1990s, Free Pascal had grown into a comprehensive compiler supporting multiple targets and implementing Object Pascal — full Delphi compatibility.

The core development team remains predominantly European:

Florian Klämpfl 🇩🇪 (Germany) — founder and lead compiler developer
Peter Vreman 🇳🇱 (Netherlands) — co-developer, linker and debugger subsystems
Mattias Gaertner 🇩🇪 (Germany) — Lazarus IDE architect and maintainer
Jonas Maebe 🇧🇪 (Belgium) — LLVM backend, Darwin/ARM support
Sven Barth 🇩🇪 (Germany) — generics implementation, language evolution

Free Pascal 3.x supports:

Object Pascal with full Delphi 2007 compatibility (modes: FPC, Delphi, ObjFPC)
Generics with type-safe containers
Interfaces and multiple interface inheritance
Operator overloading with user-defined semantics
Inline functions and compile-time constants
Native compilation to x86-64 Linux — no runtime, no JVM, no interpreter

The generated binary is self-contained. There is no runtime dependency except the C library. A Free Pascal web service compiled for Linux/amd64 can run from a FROM scratch Docker container if statically linked.

Web Services with fpWeb

Free Pascal's standard library includes fpWeb — an HTTP server framework that supports CGI, FastCGI, and standalone HTTP mode. The standalone mode creates a direct TCP listener, making fpWeb deployable in a standard Docker container without a reverse proxy for internal services.

A minimal fpWeb JSON API:

program FPWebServer;

{$mode objfpc}{$H+}

uses
  fpwebsrv, httpdefs, fphttp, sysutils, fpjson, jsonparser;

type
  TItemsModule = class(TCustomHTTPModule)
  public
    procedure HandleRequest(ARequest: TRequest; AResponse: TResponse); override;
  end;

procedure TItemsModule.HandleRequest(ARequest: TRequest; AResponse: TResponse);
var
  Data: TJSONArray;
  Item: TJSONObject;
begin
  if ARequest.PathInfo = '/health' then
  begin
    AResponse.Content := '{"status":"ok"}';
    AResponse.ContentType := 'application/json';
    AResponse.SendResponse;
    Exit;
  end;

  if (ARequest.Method = 'GET') and (ARequest.PathInfo = '/api/items') then
  begin
    Data := TJSONArray.Create;
    try
      Item := TJSONObject.Create(['id', 1, 'name', 'Example Item', 'lang', 'Free Pascal']);
      Data.Add(Item);
      AResponse.Content := Data.AsJSON;
      AResponse.ContentType := 'application/json';
    finally
      Data.Free;
    end;
    AResponse.SendResponse;
  end else
  begin
    AResponse.Code := 404;
    AResponse.Content := '{"error":"not found"}';
    AResponse.ContentType := 'application/json';
    AResponse.SendResponse;
  end;
end;

var
  App: TFPHTTPApplication;
begin
  App := TFPHTTPApplication.Create(nil);
  try
    RegisterHTTPModule('/', TItemsModule);
    App.Port := StrToIntDef(GetEnvironmentVariable('PORT'), 8080);
    App.Threaded := True;
    WriteLn('Free Pascal fpWeb listening on port ', App.Port);
    App.Run;
  finally
    App.Free;
  end;
end.

A PostgreSQL connection using the pgsql unit from Free Pascal's database library:

uses
  sqldb, pqconnection, fpjson, sysutils;

function QueryItems(const DBURL: string): TJSONArray;
var
  Conn: TPQConnection;
  Query: TSQLQuery;
  Trans: TSQLTransaction;
begin
  Result := TJSONArray.Create;
  Conn := TPQConnection.Create(nil);
  Trans := TSQLTransaction.Create(nil);
  Query := TSQLQuery.Create(nil);
  try
    // Parse DATABASE_URL: postgres://user:pass@host:port/dbname
    Conn.DatabaseName := ExtractDBName(DBURL);
    Conn.UserName     := ExtractDBUser(DBURL);
    Conn.Password     := ExtractDBPass(DBURL);
    Conn.HostName     := ExtractDBHost(DBURL);
    Conn.Transaction  := Trans;
    Trans.DataBase    := Conn;
    Conn.Open;
    Trans.StartTransaction;

    Query.DataBase := Conn;
    Query.SQL.Text := 'SELECT id, name, created_at FROM items ORDER BY created_at DESC LIMIT 50';
    Query.Open;
    while not Query.EOF do
    begin
      Result.Add(TJSONObject.Create([
        'id',         Query.FieldByName('id').AsInteger,
        'name',       Query.FieldByName('name').AsString,
        'created_at', Query.FieldByName('created_at').AsString
      ]));
      Query.Next;
    end;
    Trans.Commit;
  finally
    Query.Free;
    Trans.Free;
    Conn.Free;
  end;
end;

The pqconnection unit wraps libpq — the official PostgreSQL C client library. Free Pascal's SQL database layer provides a unified interface across PostgreSQL, MySQL, SQLite, and Oracle connections.

Dockerfile for sota.io Deployment

Free Pascal's multi-stage build separates the compiler (large) from the runtime (small):

FROM fpc:3.2.2 AS builder

WORKDIR /app
COPY src/ ./src/
COPY fpmake.pp ./

# Compile with optimisations for Linux/amd64
RUN fpc -O2 -Tlinux -Px86_64 \
        -Fu/usr/lib/fpc/3.2.2/units/x86_64-linux/* \
        -o server \
        src/server.pas

# ---- runtime stage ----
FROM debian:bookworm-slim

# fpWeb standalone mode needs libpq for PostgreSQL
RUN apt-get update && apt-get install -y \
    libpq5 \
    && rm -rf /var/lib/apt/lists/*

WORKDIR /app
COPY --from=builder /app/server ./server

EXPOSE 8080

CMD ["./server"]

The runtime image is a standard Debian slim with only libpq5. No Pascal runtime is needed — Free Pascal produces a standard native Linux binary. The image size is typically 80-100MB (Debian slim + libpq); for statically linked builds without PostgreSQL, it can be reduced to under 10MB.

Environment variables Free Pascal applications read via GetEnvironmentVariable:

DATABASE_URL — PostgreSQL connection string (sota.io managed PostgreSQL)
PORT — HTTP port (sota.io injects 8080)

GDPR Article 5(1)(f) — Integrity and Confidentiality. Pascal's strict type system prevents the buffer overflows and type confusions that produce data leakage vulnerabilities in C and C++. Every array access is bounds-checked at runtime by default. Every pointer operation on managed types is null-checked. A Pascal program cannot accidentally cast an integer to a pointer and write to an arbitrary memory address. For applications processing EU personal data, the type system is a structural guarantee against a class of memory-safety vulnerabilities.

GDPR Article 25 — Data Protection by Design. Pascal's record types map directly to the data structures of the problem domain. You define a TPersonRecord with exactly the fields needed, no more. The compiler rejects assignments between incompatible record types. The explicit, compile-time-checked data model makes it straightforward to implement GDPR's data minimisation principle in the type system itself.

EU AI Act Article 13 — Transparency. For regulated AI systems, Free Pascal's static compilation produces fully deterministic, inspectable binaries. There is no garbage collector introducing non-deterministic pauses. There is no just-in-time compiler changing the execution profile between runs. The relationship between source code and binary behaviour is direct and auditable — critical for AI systems that must demonstrate consistent behaviour across assessments.

EU Healthcare — IEC 62304 Medical Device Software. Free Pascal is used in European medical device software development. The strong typing, deterministic memory model, and native compilation without a managed runtime are required properties for IEC 62304 Class C (life-supporting device software). German and Dutch medical device manufacturers have deployed Object Pascal codebases in DICOM image processing and HL7 healthcare data pipelines for decades. The Free Pascal compiler's deterministic output satisfies certification requirements that garbage-collected languages cannot meet.

DACH Enterprise Legacy Migration. The German-speaking business software market has a high concentration of Delphi/Object Pascal applications in ERP, accounting, and document management systems. DATEV 🇩🇪 (Nuremberg, 13 million users, Germany's largest cooperative for tax advisors) uses Delphi-heritage codebases. Lexware 🇩🇪 (Freiburg, SME accounting) has Delphi roots. Free Pascal provides the compilation path to bring these applications to Linux containers and EU cloud infrastructure without rewriting.

EU Enterprises and Free Pascal Heritage

The Delphi/Free Pascal ecosystem is particularly strong in Central and Eastern Europe, where Borland's pricing strategy made Object Pascal the language of choice for the software industries that emerged in the 1990s:

Germany 🇩🇪 — DATEV (tax software, 8,000 employees, Nuremberg), Lexware (SME accounting, Freiburg), numerous Mittelstand software vendors in manufacturing automation and ERP. The Hannover Messe industrial automation ecosystem includes Delphi/FPC-based control software.

Netherlands 🇳🇱 — Financial services and healthcare software. The Dutch healthcare administration system (Zorgdomein) has components with Delphi heritage. AFAS Software (Leusden) — HR and ERP for Dutch enterprises — has Object Pascal codebases.

Austria 🇦🇹 — Vienna-based enterprise software including Fabasoft (electronic document management, listed on Vienna Stock Exchange) uses Delphi. Austrian manufacturing SMEs in the Steyr/Linz industrial corridor maintain FPC-based production systems.

Czech Republic & Slovakia 🇨🇿🇸🇰 — Strong Delphi developer communities. Numerous accounting (Pohoda, Money S3) and healthcare information systems written in Object Pascal.

Belgium 🇧🇪 — Jonas Maebe (FPC core team, Ghent) reflects the Belgian contribution to the compiler itself. Belgian payroll and HR software frequently traces to Delphi-era development.

Peter Vreman's 🇳🇱 work on the Free Pascal linker and debugger represents decades of Dutch investment in keeping Object Pascal viable as a deployment-ready language. The compiler is not an academic curiosity — it is production infrastructure for European enterprise software.

Deploy Free Pascal to Europe with sota.io

sota.io runs on Hetzner infrastructure in Germany — the country where the Free Pascal compiler was born and where the largest concentration of Delphi enterprise applications runs today.

Prerequisites:

sota.io account — free to start
Docker installed locally
Free Pascal 3.2.2+ for local development (sudo apt install fpc on Debian/Ubuntu)

Deploy steps:

Create a new project in the sota.io dashboard. Select "Dockerfile" as the build method.
Set environment variables:
- DATABASE_URL: your PostgreSQL connection string (sota.io provides managed PostgreSQL)
- PORT: 8080 (set automatically by sota.io)
Push your code. sota.io builds from the Dockerfile in your repository root. The multi-stage build compiles your Pascal source and produces a lean runtime image.
Configure health checks. sota.io expects a /health endpoint returning 200. The fpWeb handler above provides this at /health.
Scale considerations. Free Pascal's native binary has a typical startup time under 10ms — significantly faster than JVM or .NET runtimes. Horizontal scaling adds new instances in seconds. For applications migrated from Delphi, the threading model (Application.Threaded := True) maps directly to the request concurrency model sota.io uses.

Database connection. sota.io provisions PostgreSQL in the same Hetzner region as your application. The DATABASE_URL environment variable gives you the connection string in standard PostgreSQL URI format: postgres://user:password@host:5432/dbname.

Niklaus Wirth designed Pascal so that programs could be written clearly and understood easily. Anders Hejlsberg showed that a clear language could also compile fast and cost less than dinner. Florian Klämpfl showed that it could be maintained freely, by Europeans, for three decades, without losing correctness or performance. The EU enterprise software that runs on this heritage is not going away — and now it can run in a Docker container, on German infrastructure, with GDPR-compliant managed PostgreSQL.