Blaise v0.13.0 — Concurrency, Closures, and a Second Operating System 🎉

[graemeg]

Hello everyone,

v0.13.0 is our biggest cycle yet — 266 commits since v0.12.0 — and it moves
Blaise from "a self-hosting Pascal compiler" towards "a self-hosting Pascal
compiler you can build real networked, concurrent software with". Three
themes carry the release: a fibre-based async runtime with an Indy-class
networking stack, anonymous methods and closures, and a second target
operating system, FreeBSD. All of it is verified by our four self-hosting
fixpoints and a suite that has grown to 4275 tests.

🧵 A fibre runtime and a full networking stack

The headline of the cycle. Blaise now has a proper asynchronous runtime built
on stackful fibres — cheap, cooperatively-scheduled tasks — layered from the
ground up: a context-switch primitive (L0), a single- then multi-worker
work-stealing scheduler with structured-concurrency nurseries (L1), an
epoll readiness reactor (L2), fibre-aware I/O primitives (L3), and a TLS
provider over OpenSSL memory BIOs (L4).

On top of that sits an Indy-class networking library (L5): Net.Tcp,
Net.Tls, Net.Uri, an HTTP/1.1 client and keep-alive server, RFC 6455
WebSockets (client and server), and a full sweep of internet protocol
clients — SMTP, POP3, IMAP4rev1, FTP (with a passive-mode server), and NNTP
(client and server). Every one is fibre-native, so thousands of connections
share a handful of OS threads.

Structured concurrency means you spawn a group of tasks and the nursery waits
for — and cancels — them as a unit, with a fibre-root exception frame so a
failing task unwinds cleanly.

🪄 Anonymous methods and closures

Blaise gained first-class anonymous methods across ten implementation
phases: reference to function/procedure types, closures that capture outer
locals (strongly, with a [Weak Self] escape hatch), per-iteration capture in
loops, and composition with generics.

type TIntFunc = reference to function(X: Integer): Integer;
var
  Add: TIntFunc;
  N: Integer;
begin
  N := 10;
  Add := function(X: Integer): Integer
         begin Result := X + N end;   { captures N }
  WriteLn(Add(5));                     { prints 15 }
end.

We also added terse -> lambdas and a small LINQ-lite vocabulary on
TList<T>, so filtering and transforming collections reads naturally:

uses Generics.Collections;
var
  L: TList<Integer>;
  Sum, X: Integer;
begin
  L := TList<>.Create();
  L.Add(1); L.Add(2); L.Add(3); L.Add(4);
  Sum := 0;
  for X in L.Where(x -> x mod 2 = 0) do   { evens only }
    Sum := Sum + X;
  WriteLn(Sum);                            { prints 6 }
  L.Free();
end.

🐡 FreeBSD is now a first-class target

Blaise self-hosts on FreeBSD x86_64 — and cross-compiles between Linux and
FreeBSD in either direction using no external tools or packages. The internal
assembler and linker emit the foreign binary directly, and the byte-for-byte
self-hosting fixpoint is verified on both operating systems in CI. Target
selection is driven by --target, which picks the per-OS RTL layout, syscall
leaves, and conditional-compilation defines.

🏛️ Static members and richer units

Classes and records gained static (class-level) members — static var,
static function, and static properties — with full cross-unit support:

type
  TCounter = class
    static var Total: Integer;
    static function Next: Integer;
  end;

static function TCounter.Next: Integer;
begin
  TCounter.Total := TCounter.Total + 1;
  Result := TCounter.Total;
end;

Unit handling matured too: unit-qualified references (UnitName.Symbol),
cross-unit "last-in-uses wins" for types, consts and vars, type-directed
resolution of bare and qualified enum members, forward class/interface
declarations, and named integer subranges as array index types. Custom
attributes are now reified with method-level attributes and constructor
arguments, and there is an inline assembler (asm … end routine bodies).

🧱 One binary, no archive — and libc-free static binaries

We completed the RTL unification: the runtime now lives in the compiler's
own source tree and is built from source on every link path, assembled by
Blaise's internal assembler. The legacy blaise_rtl.a archive is no longer
on any self-host link line. (If you build from source via the opt-in QBE
backend, see the updated README — link the loose RTL objects with
build-rtl-objects.sh --exclude-defined-by, not the archive.)

Blaise can also now emit fully static, libc-free binaries on Linux via
direct syscalls — a freestanding _start, syscall-backed libc leaves, and
static TLS — the same foundation that made the FreeBSD port possible.

🛡️ Hardening

95 fixes landed this cycle. A large batch tightened ARC correctness
(transient releases, static-array-of-interface elements, nested-proc capture of
var-param records) and codegen on both backends (float/integer width at
store sites, unsigned zero-extension, record-return ABI, itab dispatch of
record-returning methods). Two recent, community-reported issues are fixed:
a clear error for the legacy bare-begin unit body (#172), and the QBE
build-from-source link that failed with duplicate TRtlPlatform symbols
(#174).

🧪 Real programs, not just tests

Two standalone Blaise projects landed alongside the compiler this cycle — both
are on GitHub, both build with v0.13.0:

• blaise-microservice-demo —
  a port of the Java Virtual Threads "API aggregator" demo. An HTTP server whose
  /aggregate endpoint fans out three downstream calls (2 s each) that complete
  in ~2 s wall-clock, not 6 s, using the fibre TTaskGroup nursery and the
  M:N scheduler. It ships with a mini-Gatling load generator that ramps to
  6000 concurrent virtual users on a handful of OS threads — no framework, no
  GC, an instant-start ~3 MB native binary. The README puts the Blaise and Java
  versions side by side; the code reads exactly like blocking code.

• luhmann — a
  Zettelkasten note server written
  entirely in Blaise. It turns a directory of AsciiDoc notes into a linked web
  of pages served over HTTP, with an interactive note graph and a JSON API —
  and renders the whole collection concurrently at start-up, so even a large
  Zettelkasten is ready in a second or two.

Both are great starting points if you want to see the async stack and stdlib
used in anger.

📈 By the numbers

• Self-hosting fixpoint: 498,507 lines of QBE IR, byte-for-byte stable.
• All four fixpoints green: QBE, native, internal-assembler, warm-cache.
• Tests: 4275, passing on Linux and FreeBSD.
• Backends: native x86-64 (default) and QBE, both passing the full suite.

Grab the release from the GitHub releases page, and see
here for the full technical detail.

Thank you to everyone who filed issues and tried the builds this cycle — the
FreeBSD port and many fixes came straight from community testing.

Onwards to v0.14.0! 🙌

---

Built with ❤ for the Pascal community.

[andrewd207]

@graeme Now that external with a libname is available and there's a release with the feature, at least some of the hardcoded link options can be removed and external 'name' can be added to the declarations for it to happen automatically. If we are still linking to libc anyway :)

[fredvs]

If we are still linking to libc anyway :)

I'm not sure I understand. Okay, Blaise itself could be independent of libc like FPC compiler, but does that mean most of libc's methods could be implemented by pure Blaise?

[graemeg]

Is libc still linked?

• Linux, default build: yes
• Linux --static: no libc at all
• FreeBSD, default: already libc-free

Could most of libc be implemented in pure Blaise?

• Yes, but it's not needed to implement all of libc. We only need to implement the slices of what we need for Blaise. Which is already done.

Replacing the hardcoded -lm/-lpthread with external 'm'/external 'pthread' declarations so linking happens automatically: yes, that's now possible and is already planned as my first clean-up tasks for the v0.14.0 dev cycle. Flipping the switch for the Linux target, so --static behaviour becomes the default (like FreeBSD) is also planned.

[fredvs]

Ha, perfect. Maybe if some methods from libc are still needed, for Linux, use the signed symbol tables to have a binary compatible with old, present and future os, like:

const
  // allow to assign proper signed symbol table name for a libc.so.6 method
  {$if defined(linux) and defined(cpux86_64)}
  LIBC_SUFFIX = '@GLIBC_2.2.5';
  LIBC_SUFFIX2 = '@GLIBC_2.2.5';
  LIBC_SUFFIX3 = '@GLIBC_2.2.5';
  {$else}
   {$if defined(linux) and defined(cpuarm)}
  LIBC_SUFFIX =  '@GLIBC_2.4';
  LIBC_SUFFIX2 = '@GLIBC_2.4';
  LIBC_SUFFIX3 = '@GLIBC_2.4';
  {$else}
  {$if defined(linux) and defined(cpui386)}
  LIBC_SUFFIX = '@GLIBC_2.0';
  LIBC_SUFFIX2 = '@GLIBC_2.1';
  LIBC_SUFFIX3 = '@GLIBC_2.2';
  {$else}
  LIBC_SUFFIX = '';
  LIBC_SUFFIX2 = '';
  LIBC_SUFFIX3 = '';
  {$endif}
  {$endif}  
  {$endif}

...

function fsync(__fd: cint): cint; cdecl; external 'libc' name 'fsync' + LIBC_SUFFIX;
...
function __fxstat64(__ver:longint; __fildes:longint; __stat_buf:Pstat64):longint;
                             cdecl;external 'libc' name '__fxstat64' + LIBC_SUFFIX2;
...
function readdir64_r(__dirp:PDIR):Pdirent64;cdecl;external 'libc' name 'readdir' + LIBC_SUFFIX3;          

[fredvs]

And also, if possible, allow an extended filename for libraries like external 'libc.so.6' as kylix, clang and gcc do (and not remove the '.6' part at compilation/linking as fpc does).

[LaskaIDK]

Really interesting project!
Looking forward to Blaise