Chaos and Order

💡 왼쪽 원문을 읽으면서 오른쪽에 따라 써보세요. Tab 키로 힌트를 받을 수 있습니다.

원문 렌더가 준비되기 전까지 텍스트 가이드로 표시합니다.

Prologue — Who Still Writes Pascal in 2026

"Pascal? Is that not the language schools used to teach?"

In May 2026 I still get this question. The answer is the opposite of what most assume. **Pascal is alive — and doing well.**

- **Bank core systems** — Germany's Sparkasse, Poland's PKO BP, parts of Sberbank's core were written in Delphi and are still maintained in 2026.

- **Insurance back offices** — Parts of Samsung Life and Hanwha Life in Korea, and back-office systems at Nomura and Mitsubishi UFJ in Japan, still run Delphi.

- **Manufacturing SCADA and MES** — Many factory HMIs at Siemens, Festo, and Bosch are still Delphi.

- **Government ERP** — Eastern European and Russian government systems, some Korean municipal systems.

- **Game engines** — Michalis Kamburelis's **Castle Game Engine** is an open-source 3D engine written entirely in Object Pascal.

- **Schools** — Universities and high schools in Poland, Russia, Ukraine, and the Czech Republic still teach algorithms in Pascal.

And in November 2025, Embarcadero released **RAD Studio 12 Athens**, combining Delphi 12 and C++Builder 12 in one IDE with AI Code Insight, Skia integration, a refreshed FireMonkey FMX, and full targeting of macOS Tahoe and iOS 19. The Free Pascal team shipped **3.2.4** as a stabilization release and stabilized the **3.3.x trunk** in the same month; Lazarus 3.10 followed.

This article walks the entire Pascal ecosystem in one breath — from RAD Studio 12 down through FPC, Lazarus, Castle Game Engine, Oxygene, and TMS WEB Core/pas2js — and ends with an honest answer to "why do people still write Pascal."

1. A Short History of Pascal — 1970 to 2026

One thing first: the Pascal of 2026 is not the Turbo Pascal of 1985.

- **1970** — Niklaus Wirth designs Pascal at ETH Zurich. An educational language.

- **1983** — Borland Turbo Pascal 1.0. A compiler for the IBM PC at 49 dollars. Explosive popularity.

- **1995** — Borland Delphi 1. Object Pascal plus a RAD GUI. Becomes the standard for Windows development.

- **1999** — Free Pascal Compiler (FPC) 1.0. An open-source Pascal compiler.

- **2008** — Embarcadero acquires Delphi from Borland.

- **2011** — Delphi XE2 introduces FireMonkey FMX. Cross-platform (Mac, iOS) support arrives.

- **2017** — Castle Game Engine 6.0. A serious 3D engine.

- **2023** — RAD Studio 11 Alexandria.

- **2024** — Initial release of RAD Studio 12 Athens.

- **November 2025** — RAD Studio 12.3 update, FPC 3.2.4, Lazarus 3.10.

- **April 2026** — FPC 3.3.x trunk lands full ARM64 macOS Tahoe and iOS 19 support, plus Linux RISC-V in beta.

The point: **Pascal did not stop at Delphi 1995.** Generics (Delphi 2009), anonymous methods (2009), attributes (2010), inline variables (Delphi 10.3), managed records (Delphi 10.4) — almost every feature of a modern language is in Object Pascal too.

2. Embarcadero RAD Studio 12 Athens — The Mothership Today

RAD Studio bundles Delphi and C++Builder in one IDE. As of the **12.3 update in November 2025**, the core features are:

- **Languages** — Delphi (Object Pascal) 12, C++Builder 12 (Clang 17 based)

- **UI frameworks** — VCL (Windows native), FireMonkey FMX (cross-platform)

- **Target platforms** — Windows 11 24H2, macOS Tahoe (arm64 and x86_64), iOS 19, Android 16, Linux (x86_64 and arm64)

- **AI Code Insight** — January 2026 12.3 update added OpenAI, Azure OpenAI, and local Ollama integration for completion and refactoring suggestions

- **Skia integration** — Skia4Delphi is now the default graphics backend for FMX and VCL. Text rendering, SVG, and animation get a tier upgrade.

- **New components** — `TSkLabel`, `TSkAnimatedImage`, `TSkSVG`, and a refreshed `TMultiView`

- **DocInsight** — automatic function doc extraction and inline display

**Pricing** (as of May 2026):

| Edition | Perpetual | Annual subscription |

|---|---|---|

| Community (personal, revenue under 5000 USD) | Free | Free |

| Professional | About 1,899 USD | About 829 USD per year |

| Enterprise | About 3,499 USD | About 1,599 USD per year |

| Architect | About 5,499 USD | About 2,499 USD per year |

**Honest assessment**:

Strengths — VCL is still the most mature GUI framework on Windows. Compilation is extremely fast (medium and large projects compile in tens of seconds). Single-EXE deployment. Deterministic memory and resource management.

Weaknesses — License pricing is steep for hobbyists. Mac, Linux, and iOS targeting works but is not as smooth as Windows. Mobile UI feels a bit dated compared to Flutter and React Native.

3. FreePascal 3.2 and 3.3 — The Free Open-Source Compiler

The Free Pascal Compiler (FPC), started in 1993, is the open-source Pascal compiler. As of May 2026, the stable line is **3.2.4** and the trunk is **3.3.x**.

**Supported platforms** (2026):

- **Operating systems** — Windows (x86, x86_64, arm64), Linux (x86, x86_64, arm32, arm64, RISC-V64), macOS (x86_64, arm64), FreeBSD, OpenBSD, NetBSD, Solaris, Haiku, AIX, OS/2, DOS

- **Architectures** — x86, x86_64, ARM (32 and 64), MIPS, PowerPC, SPARC, RISC-V32 and 64, AVR, WebAssembly, JVM

- **Mobile** — iOS, Android, Tizen, Sailfish OS

This matrix rivals GCC and LLVM. And compile speed is among the very fastest of any compiler — a million-line project compiles in seconds, not minutes.

**Delphi compatibility** — With `mode Delphi`, FPC compiles Delphi 7 to XE code nearly unchanged. Some Delphi 12 features (parts of managed records, etc.) are not yet supported, but over 90 percent of Delphi code compiles in FPC.

**Object Pascal mode** — `mode ObjFPC` is FPC's native mode with stricter syntax but a more modern feel. Explicit `Self`, `@` before method pointers, and so on.

4. Lazarus 3.x — The RAD IDE for Free Pascal

FPC is the compiler; Lazarus is the IDE plus RAD library on top of it. As of **Lazarus 3.10** in November 2025:

- **LCL (Lazarus Component Library)** — An API very similar to VCL. `TForm`, `TButton`, `TEdit`, `TStringGrid`, `TPageControl`, and friends are nearly identical.

- **Widget sets** — One codebase deploys to Win32, GTK2 and 3, Qt5 and 6, Cocoa, Carbon, and CustomDrawn.

- **Form designer** — Almost identical drag-and-drop UI design to Delphi.

- **Debugger** — Choose GDB, LLDB, or FpDebug (a pure-Pascal debugger).

- **Refactoring** — Method extraction, rename, class completion.

**Why Lazarus is attractive**:

1. **Completely free** — GPL and LGPL, commercial use allowed.

2. **One codebase for Win, Mac, Linux, and BSD** — An API close to VCL.

3. **Legacy Delphi migration** — Usually 80 to 95 percent compiles unchanged.

4. **Fast compile and small executables** — No external runtime dependency.

**Weaknesses**:

- Mobile support is weak (possible but rough).

- UI design feels 1990s — modern Material or Flat must be drawn by hand.

- Some database drivers (MSSQL, Oracle) need third-party components.

5. The Object Pascal Language — What It Actually Is in 2026

The "Pascal is an old language" stereotype belongs to someone who stopped looking in 1990. In 2026, Object Pascal has all of the following:

- **Classes and interfaces** — `class`, `interface`, multiple interface implementations

- **Generics** — `TList<T>`, `TDictionary<K, V>`, constraints (`class`, `constructor`)

- **Anonymous methods** — `procedure of object` plus `reference to procedure` (closures)

- **Attributes** — `[Inject]`, `[Route('/api/v1/users')]`

- **Inline variables** — `for var i := 0 to 9 do`

- **Managed records** — automatic `Initialize`, `Finalize`, and `AssignOperator`

- **Operator overloading** — for records and classes

- **RTTI** — runtime type inspection and mutation

- **async and await** — officially supported in Delphi 12 Athens

Here is a slice of modern Object Pascal. Inline variables, managed records, and generic methods are all present.

program ModernPascalDemo;

{$mode Delphi}{$H+}

uses

System.SysUtils, System.Generics.Collections;

type

TUser = record

Id: Integer;

Name: string;

class operator Initialize(out U: TUser);

class operator Finalize(var U: TUser);

end;

class operator TUser.Initialize(out U: TUser);

begin

U.Id := 0;

U.Name := '';

end;

class operator TUser.Finalize(var U: TUser);

begin

WriteLn('User ', U.Name, ' is gone');

end;

function FindByName<T>(const Items: TArray<T>; const Pred: TFunc<T, Boolean>): T;

begin

for var Item in Items do

if Pred(Item) then Exit(Item);

Result := Default(T);

end;

var

Users: TArray<TUser>;

begin

SetLength(Users, 2);

Users[0].Id := 1; Users[0].Name := 'Alice';

Users[1].Id := 2; Users[1].Name := 'Bob';

var Found := FindByName<TUser>(Users,

function(U: TUser): Boolean begin Result := U.Name = 'Bob'; end);

WriteLn('Found: ', Found.Name);

end.

Still feels like an "old language"? Read it once and judge again.

6. Modern Object Pascal Introduction — Michalis Kamburelis's Free Book

Michalis Kamburelis is the maintainer of **Castle Game Engine** and a pillar of the Object Pascal community. His **"Modern Object Pascal Introduction for Programmers"** (about 80 pages) is the shortest path from another language into Pascal.

The structure:

1. **Type system** — `Integer`, `string`, `array`, `record`, `class`, `interface`

2. **Memory management** — `New` and `Dispose`, ARC, managed types

3. **Object orientation** — `class`, visibility, inheritance, interfaces, virtual and override

4. **Generics** — `TList<T>` and writing your own

5. **Control flow** — anonymous methods, for-in, the `with` statement (not recommended)

6. **Modules** — `unit`, `uses`, `interface` and `implementation` sections

7. **Build systems** — fpmake, lazbuild, Delphi MSBuild

The book is free and downloadable as a single file from the Castle Game Engine site. It is equally useful to a first-time Pascal reader and someone who stopped at Delphi 7.

7. Castle Game Engine — A 3D Engine Written in Object Pascal

Castle Game Engine started in 2001 and is an open-source 3D engine. As of December 2025, the stable line is **7.0-alpha.3**; the **7.0** release is imminent in May 2026.

**Core features**:

- **Language** — Object Pascal (FPC plus Lazarus, also Delphi 11 and 12)

- **Rendering** — OpenGL ES 3, Vulkan (beta in 2026), WebGL (via pas2js, experimental)

- **Scene formats** — glTF 2.0, X3D, Spine 2D, MD3, OBJ, Collada, STL

- **Physics** — Kraft (pure-Pascal 3D physics) plus Box2D

- **Sound** — OpenAL Soft

- **VR** — OpenXR support — works on Meta Quest 3 and 3S

- **Build targets** — Windows, Linux, macOS, FreeBSD, Android, iOS, Nintendo Switch (commercial license)

**Why pick Castle Game Engine**:

1. **Compilation is fast** — Unity takes minutes, Unreal longer. Castle takes seconds.

2. **Single executable** — no external runtime.

3. **Deterministic memory** — no GC pauses.

4. **Free and open source** — Apache 2.0.

5. **Both 2D and 3D** — Spine, Tiled, Cocos2d assets import directly.

**Weaknesses** — Smaller community than Unity or Unreal, the visual editor is still maturing, no visual-script equivalent of Unreal Blueprint.

8. TMS Software — A Specialist Delphi Component Vendor

TMS Software is a Belgian Delphi and C++Builder component vendor. As of May 2026, the core products are:

- **TMS FNC UI Pack** — VCL, FMX, LCL, and Web with one codebase (Framework Neutral Components)

- **TMS WEB Core** — A web framework that compiles Pascal to JavaScript (next chapter)

- **TMS XData** — A REST API server framework

- **TMS Aurelius** — A Hibernate-style ORM

- **TMS Sparkle** — HTTP and WebSocket client

- **TMS Echo** — Database sync and replication

**TMS All-Access subscription** — All TMS products together for roughly 1,500 EUR per year (May 2026). The most common bundle at mid-sized Delphi shops.

9. DevExpress VCL — The Standard for Windows Enterprise UI

DevExpress is a US-based (originally Ukrainian) UI vendor strong across .NET, JS, and Delphi. On the Delphi side the key products are:

- **ExpressQuantumGrid** — The de facto standard VCL grid

- **ExpressBars** — Ribbon UI and dock panels

- **ExpressEditors** — A bundle of input components

- **ExpressPivotGrid** — Pivot tables

- **ExpressScheduler** — Calendar and scheduler

Perpetual licenses start around 1,500 USD. More than half of Korean financial and government Delphi projects ship DevExpress VCL.

10. Skia for Delphi — A Modern Graphics Stack

Skia is Google's 2D graphics library, the one behind Chrome, Flutter, and Android. **Skia4Delphi** is an open-source binding bringing Skia to Delphi and Lazarus, and since 2025 it has been the default graphics backend for FMX and VCL in RAD Studio 12.

**What you get**:

- Antialiasing and text rendering go up a tier (especially for Korean, Japanese, and Chinese)

- Direct SVG rendering

- Lottie animation playback

- GPU-accelerated 2D

- Shader support (SkSL)

The Delphi 12 standard components `TSkLabel`, `TSkAnimatedImage`, and `TSkSVG` are built on this. It outperforms the GDI+ based Canvas of the 2010s in every dimension.

11. Spring4D — Modern Delphi DI and Collections

**Spring4D** is a Delphi library inspired by Spring in .NET and Spring in Java. As of May 2026, the stable line is **2.0**.

**Components**:

- `Spring.Container` — IoC container (constructor injection, attribute-based)

- `Spring.Collections` — Modern collections (`IList<T>`, `IDictionary<K, V>`, LINQ-style queries)

- `Spring.Persistence` — Marshmallow ORM

- `Spring.Reactive` — Rx.NET port

Example DI usage:

uses Spring.Container, Spring.Container.Common;

type

[Inject]

IUserService = interface

function FindByEmail(const Email: string): IUser;

end;

TUserController = class

private

[Inject]

FUserService: IUserService;

public

procedure HandleRequest;

end;

var

Container: TContainer;

begin

Container := TContainer.Create;

Container.RegisterType<TUserService>.Implements<IUserService>;

Container.RegisterType<TUserController>;

Container.Build;

var Controller := Container.Resolve<TUserController>;

Controller.HandleRequest;

end.

It is the de facto standard in enterprise Delphi projects.

12. PascalABC.NET — A Russian Academic .NET Pascal

**PascalABC.NET** is a .NET-based Pascal developed at Saratov State University in Russia. It is built for education and algorithm practice and is the standard language in algorithm classes across Russia, Ukraine, and Belarus.

**Highlights**:

- Runs on .NET 6, 7, and 8 — imports C# libraries directly

- LINQ in Pascal syntax — `Range(1, 10).Where(x to x mod 2 = 0).Sum`

- Object-oriented, functional, and procedural together

- A very lightweight student-friendly GUI IDE

- Windows, Linux, and macOS

Few people outside the classroom use it, but for Russian-speaking students PascalABC.NET is their first Pascal.

13. Oxygene — RemObjects's Multi-Target Pascal

**Oxygene** is a modern Pascal dialect from RemObjects Software. It runs on the **Elements** compiler and compiles the same Pascal source to .NET, Java and Android, iOS and macOS (Cocoa), and WebAssembly.

**Per-platform targets**:

- **.NET** — Same IL and GC as C# and F#

- **Cocoa** — Objective-C and Swift runtime, ARC

- **Java and Android** — JVM bytecode, can also use the Android NDK

- **Island (native)** — Self-hosted runtime, native binary output

- **WebAssembly** — Wasm and WASI

Elements also supports **Hydra**, **Mercury** (a modern Visual Basic), **Iodine** (Java-compatible), **Silver** (Swift-compatible), and **Go** (Go-compatible) in the same toolchain.

Oxygene is sold by RemObjects subscription, starting around 999 USD per year (May 2026). The market is small in practice, but teams attracted by "one codebase for .NET, iOS, Android, and Web" choose it.

14. Hydra — Multi-Language Hosting

Also from RemObjects, **Hydra** is a library that hosts Delphi, .NET, and Java objects in a single process. You can drop a .NET WPF control onto a Delphi VCL form, and embed a Java Swing panel inside that.

Uses:

- Adding .NET modules to a legacy Delphi app incrementally

- Calling C# business logic from a Delphi UI

- Embedding a Java analytics module on a Delphi form

**Honest take**: It looks great but is awkward in practice. Memory models, event loops, and exception handling differ across languages. For a real migration, picking one language consistently is usually wiser.

15. mORMot — The REST and ORM Framework for Delphi

**mORMot** (Synopse mORMot) is an open-source framework by French developer Arnaud Bouchez. As of May 2026, **mORMot 2** is stable.

**Components**:

- **mORMot Core** — JSON, RTTI, compression, encryption, logging — a foundation library roughly equivalent to the .NET BCL

- **mORMot ORM** — Code-first ORM, embedded SQLite

- **mORMot SOA** — Interface-based RPC plus REST

- **mORMot DB** — Drivers for Oracle, PostgreSQL, MySQL, MSSQL

- **mORMot Reports** — PDF and Excel generation

- **mORMot AI** — Added in 2026, an LLM client (OpenAI, Anthropic, Ollama)

**Why mORMot**:

1. **Very fast** — The SQLite backend handles tens to hundreds of thousands of transactions per second.

2. **Single executable** — Almost no dependencies.

3. **Interface-based SOA** — A Pascal interface is exposed as REST directly.

4. **Free and open source** — Triple-licensed MPL, GPL, and LGPL.

On the server side of an enterprise Delphi project, mORMot is the de facto standard.

16. DataSnap — Embarcadero's Official RAD Client and Server

**DataSnap** is Embarcadero's official RAD client and server framework, bundled with RAD Studio Enterprise and above.

**Features**:

- Automatic REST server generation (interface to REST endpoints)

- WebSocket support

- Multiple clients — Delphi, JavaScript, Java, PHP

- JSON, XML, and binary serialization

- Session management and authentication

**Honest take**: DataSnap works, but in performance and flexibility it lags mORMot. For a brand-new project in 2026, far more teams pick mORMot.

17. Indy and ICS — Two Networking Camps in Delphi

When writing TCP, UDP, HTTP, FTP, or SMTP in Delphi, you have two choices.

**Indy (Internet Direct)**:

- Bundled with RAD Studio

- Blocking I/O first (scaled via thread pools)

- Over 60 components — IdHTTP, IdSMTP, IdFTP, IdTCPServer, and friends

- Easy to use, battle-tested for stability

**ICS (Internet Component Suite)**:

- Free library by Francois Piette

- Non-blocking I/O first (event-driven)

- Early support for IPv6, TLS 1.3, HTTP/2

- Fits high-performance servers

**When to use which**:

| Use case | Recommendation |

|---|---|

| Simple HTTP client | Indy (IdHTTP) |

| High-performance TCP server | ICS |

| SMTP, POP3, IMAP client | Indy |

| HTTPS WebSocket server | ICS or mORMot |

18. REST.Json and System.Net — Delphi Standard Library

Since Delphi XE6, the standard library has a modern REST and JSON stack.

- `REST.Client.TRESTClient` — REST client

- `REST.Json.TJson` — Automatic object-to-JSON serialization

- `System.Net.HttpClient.THTTPClient` — HTTP/2 client without Indy

- `System.JSON` — DOM-style JSON parser

This standard library experimentally supports HTTP/3 (QUIC) in RAD Studio 12 (January 2026 update).

19. TMS WEB Core and pas2js — Pascal to JavaScript

**pas2js** is the Pascal-to-JavaScript compiler from the Free Pascal team. **TMS WEB Core** is the commercial product layering RAD tooling on top.

**What you get**:

- Pascal source is transpiled to JavaScript and runs in the browser

- The same form designer for the web — a Pascal `TWebButton` renders as an HTML button element

- Pascal interfaces deliver TypeScript-like type safety

- PWA, service worker, and WebAssembly output

**TMS WEB Core 2.6** (January 2026) features:

- Embed React, Vue, and Svelte components

- Capacitor integration — same code targets iOS and Android natively

- Electron integration — desktop apps

- Themes for Bootstrap 5, Tailwind CSS, and Bulma

**Use cases** — A legacy Delphi team that wants to build a web frontend in the same language. For a team starting their first web project from scratch, React or Vue is the more realistic pick.

20. Smart Pascal and Elements — Other Pascal Variants

Beyond the RAD Studio family covered above, several Pascal variants exist.

- **Smart Pascal** (Smart Mobile Studio) — Pascal to JavaScript; nearly discontinued but some teams still use it

- **Elements** (RemObjects) — Oxygene Pascal plus Mercury VB plus Iodine Java plus Silver Swift plus Go in one compiler

- **MorphOS Pascal** — For Amiga MorphOS

- **JEDI Pascal** — Pascal standard library plus JCL and JVCL components

- **Virtual Pascal** — For OS/2 and Win 16; essentially museum-tier

For a new project in 2026, start with one of three: RAD Studio 12, Lazarus 3, or Castle Game Engine.

21. Real-World 2026 Pascal Use — Five Scenarios

A concrete answer to "who still writes Pascal".

Scenario A — Bank core system maintenance

Poland's PKO BP, Germany's Sparkasse, and parts of Eastern European and Russian banks wrote their cores in Delphi between 1990 and 2010, and they are still maintained in 2026. New features arrive via mORMot and Spring4D; clients remain VCL.

Scenario B — Manufacturing SCADA and MES

A large share of factory HMIs at Siemens, Bosch, and Festo were built in Delphi. Real-time data, serial and Modbus, and OPC UA all run well in Delphi. New SCADA in 2026 trends toward .NET or C++, but existing assets stay.

Scenario C — Game engine development

Indie 3D games built with Castle Game Engine. Pascal's compile speed and deterministic memory map well to a game loop. VR and Switch targets are reachable.

Scenario D — Windows desktop LOB apps

ERP, CRM, inventory, and POS for mid-sized companies — memory footprint is one-tenth of Tauri or Electron, executable size is one-fifth. VCL and LCL grids and charts remain strong.

Scenario E — Education and algorithms

The Polish IOI team and the Russian IOI team use Pascal (alongside C++). PascalABC.NET and FPC are common school IDEs.

22. Migration Paths — If You Leave

"If we move our Delphi code to another language, where do we go?"

**Option 1 — Stay on Delphi but modernize**

- Introduce Spring4D, mORMot, and Skia4Delphi

- VCL and FMX collapse to FMX only

- DataSnap to mORMot REST

- The most conservative and safest path

**Option 2 — Delphi to Lazarus**

- License cost goes to zero

- LCL is 80 to 95 percent API-compatible with VCL

- Downsides: weak mobile, missing commercial components

**Option 3 — Delphi to C# (.NET)**

- The most natural migration — object model, exceptions, and events all map cleanly

- UI is rewritten in WPF, WinUI 3, or MAUI

- A one-to-three-year project, high cost

**Option 4 — Delphi to Rust plus Tauri**

- Memory safety and high performance

- UI moves to the web (React) — needs designer headcount

- Ambitious, two to five years

**Option 5 — Delphi to Go**

- A simple server works; GUI is weak

- Microservice decomposition, then iterative migration

Most teams pick option 1 or 2. The larger the codebase, the truer this becomes.

23. Famous Software Written in Delphi

Evidence that Delphi was widely used in practice.

- **Skype** (early 2003 version; later rewritten in C++)

- **Total Commander** — file manager (Delphi)

- **FL Studio** (Image-Line) — DAW. The main codebase is still Delphi in 2026.

- **WinRAR** (parts)

- **The Bat!** — email client

- **JPSoft 4NT and TCC** — Windows shells

- **MediaMonkey** — music library

- **InnoSetup** (Jordan Russell) — installer written in Delphi 7

- **PowerBASIC** — some components

- **Embarcadero RAD Studio itself** — much of the IDE is written in Delphi (a recursive self-compilation).

All of these still ship in the tens of millions of downloads.

24. The Delphi Communities in Korea, Japan, and Eastern Europe

**Korea** — The Delphi User Group (DelphiKorea) was founded in 1996 and remains active in 2026. Regular seminars, the KFD (Korea Free Delphi) group, and around 8,000 members on the Naver cafe. Financial and government SI projects still hire Delphi engineers.

**Japan** — Delphi User Group and Embarcadero Tech Days Japan (once a year). Regular meetups in Tokyo and Osaka. Some large Japanese game studios use Delphi for client tooling.

**Poland, Russia, Ukraine** — The largest Delphi community. Pascal is one of the standard languages for algorithms in school. SpaceCRM, Roxen, and some Kaspersky tools are in Delphi.

**Germany** — The most mature enterprise Delphi market. The EKON conference runs every year.

**Brazil** — The largest Delphi market in Latin America. EmbarcaderoBR is very active.

25. Why People Still Write Pascal — An Honest Answer

The central question of this article. Five answers.

1. **Compile speed** — A million-line project compiles in seconds, not minutes. CI gets faster and the inner loop tightens.

2. **Native single EXE** — No JVM, no runtime, no interpreter. Deployment is simple.

3. **Deterministic resource management** — No GC pauses. A fit for embedded and industrial control.

4. **VCL, FMX, and LCL component assets** — 25 years of components still work.

5. **Sentiment and inertia** — Developers who picked up Delphi 1 in 1995 are in their 50s now. They built companies, and those companies' code is Delphi.

The fifth answer is the most honest and the most powerful motive. People work with the tools they know well.

26. Compared to Modern Alternatives

If you did the same job in another language?

|---|---|---|---|---|---|

| Memory safety | Manual or partial | GC | Compile-time | GC | GC |

**Summary** — The strengths of Pascal and Delphi are "native Windows GUI plus fast compile plus deterministic memory". Unless those three are core requirements, a new 2026 project usually goes to another language.

27. Recommended Learning Path — From Zero to One

If you are picking up Pascal for the first time, or returning to it:

1. **Language basics** — "Modern Object Pascal Introduction" by Michalis Kamburelis (free PDF, 80 pages)

2. **Get the IDE in hand** — Install Lazarus 3 and build a simple calculator app with the form designer

3. **Components and events** — `TButton.OnClick`, `TEdit.OnChange`, `TStringGrid`

4. **First mini-project** — A TODO app (SQLite backend) using Spring4D collections

5. **REST client** — Call a public API with `System.Net.HttpClient`

6. **First game** — Follow the Castle Game Engine tutorial and roll a 3D cube

7. **Books** — "Object Pascal Handbook" or "Mastering Delphi" by Marco Cantù

8. **Community** — DelphiKorea, the r/delphi and r/fpc subreddits, the Lazarus forum

Three months is enough to be comfortable. Pascal's BEGIN and END are a bit verbose, but that is the only catch.

28. Common Pitfalls and Answers

**"Is Pascal not a dead language?"**

That impression stalled in the 1990s. RAD Studio 12, FPC 3.3, and Lazarus 3.10 ship regularly in 2026. Modern libraries like mORMot, Castle, and Spring4D are active.

**"BEGIN and END are too long."**

At first, yes. A month is enough to get used to. And BEGIN and END produce clearer diagnostics than a one-character brace.

**"VCL components look dated."**

With Skia4Delphi and Material libraries, modern designs are reachable. The default components look 1990s only if you choose to leave them alone.

**"There are few libraries."**

Compared to NPM or PyPI, yes. But GetIt (the RAD Studio package manager), DelphiNES, the JEDI Code Library, and the mORMot ecosystem cover most everyday needs.

**"The job market is small."**

Small but well paid. Senior Delphi salaries in Poland, Germany, and Japan are equal to or slightly above those of comparable Java or C# seniors. Supply is short.

**"Lazarus is free but has no commercial support."**

Lazarus itself is GPL and LGPL. Buy commercial support by moving to Embarcadero RAD Studio or by buying from vendors like TMS, DevExpress, and SDL Components. Lazarus alone is enough for plenty of commercial projects.

29. Books and Resources

Worthwhile books (as of 2026):

- **Marco Cantu — "Object Pascal Handbook"** (2014, the most authoritative language reference)

- **Marco Cantu — "Mastering Delphi"** series (classic, Delphi 1 to 7)

- **Michalis Kamburelis — "Modern Object Pascal Introduction for Programmers"** (free, 2024 revision)

- **Nick Hodges — "Coding in Delphi"** and "More Coding in Delphi"

- **Primoz Gabrijelcic — "Delphi High Performance"** (2018)

- **William Meyer — "Delphi GUI Programming with FireMonkey"** (2020)

- **Marko Tasic — "FreePascal from Square One"** (2023)

- **Khaled Aljundi — "Delphi GUI Programming with FireMonkey"** (2021)

English material dominates. In Korean, look at the DelphiKorea forum; in Japanese, "Hachi Obu Jima" and "Programming Delphi" carry the torch.

30. Conclusion — A Stable Giant on the Shoulders of Giants

Pascal was designed by Niklaus Wirth in 1970 as an educational language. Fifty-six years later, in 2026, Pascal is alive and very much working.

The thirty chapters above compress to one sentence.

**Pascal survived "where it was needed". It is not the new trend, but there is no better tool for running old code well.**

- **If you are starting fresh** — Lazarus 3 and FPC 3.3 for free. When comfortable, Castle Game Engine for games.

- **If your company uses Delphi** — RAD Studio 12 Athens. Adopt Spring4D, mORMot, and Skia4Delphi to modernize the codebase.

- **If you intend to leave** — C# and .NET are the most natural migration. Rust is ambitious but expensive.

- **If pure curiosity** — One Marco Cantu book and you are productive in a month.

Pascal users do not chase trends. They chase **making working code keep working**. In 2026, that value still holds.

References

1. Embarcadero — RAD Studio 12 Athens: https://www.embarcadero.com/products/rad-studio

2. Embarcadero — Delphi 12 What's New: https://docwiki.embarcadero.com/RADStudio/Athens/en/What%27s_New

3. Free Pascal Compiler: https://www.freepascal.org/

4. FPC 3.2.4 Release Notes: https://wiki.freepascal.org/FPC_New_Features_3.2.4

5. Lazarus IDE: https://www.lazarus-ide.org/

6. Castle Game Engine: https://castle-engine.io/

7. Modern Object Pascal Introduction (Michalis Kamburelis): https://castle-engine.io/modern_pascal

8. Marco Cantu blog: https://blog.marcocantu.com/

9. Object Pascal Handbook (Marco Cantu): https://www.marcocantu.com/objectpascalhandbook/

10. TMS Software: https://www.tmssoftware.com/

11. TMS WEB Core: https://www.tmssoftware.com/site/tmswebcore.asp

12. DevExpress VCL: https://www.devexpress.com/products/vcl/

13. Skia4Delphi: https://skia4delphi.org/

14. Spring4D: https://www.spring4d.org/

15. mORMot: https://github.com/synopse/mORMot2

16. PascalABC.NET: https://pascalabc.net/

17. RemObjects Oxygene: https://www.elementscompiler.com/elements/oxygene/

18. RemObjects Hydra: https://www.remobjects.com/hydra/

19. Indy Project: https://www.indyproject.org/

20. ICS (Internet Component Suite): https://www.overbyte.eu/

21. pas2js: https://wiki.freepascal.org/pas2js

22. JEDI Code Library: https://www.delphi-jedi.org/

23. DelphiKorea (Delphi User Group): https://cafe.naver.com/delmadang

24. Lazarus Forum: https://forum.lazarus.freepascal.org/

25. Embarcadero Community: https://community.idera.com/developer-tools/

26. Delphi Reddit: https://www.reddit.com/r/delphi/

27. Free Pascal Reddit: https://www.reddit.com/r/fpc/

28. EKON Conference: https://entwickler-konferenz.de/ekon/

29. Embarcadero Tech Days Japan: https://www.embarcadero.com/jp/

30. Nick Hodges blog: https://www.nickhodges.com/