Blaise v0.14.0 is here 🎉 - macOS, BlaiseGuard, math and more...

[graemeg]

This has been our biggest cycle yet — 415 commits since v0.13.0 — and the
headline is simple: Blaise now has a working native ARM64 backend for
macOS. We are not done with the macOS port (there's still real work ahead
on the debugger side and broader on-device coverage), but the compiler
itself can already generate, assemble, link and code-sign Mach-O binaries
for Apple Silicon, and it can cross-compile a growing slice of its own
source onto that target. Progress is real and it's landing steadily.

Alongside that, this cycle brought operator overloading, compile-time file
embedding, a brand-new static analyser, and a long list of hardening fixes
across both backends. Full details are in the changelog.

🍎 macOS ARM64 — from zero to self-cross-compiling

The bulk of this cycle's work (over 150 commits) went into building a
complete ARM64/macOS backend from the ground up:

• A native AArch64 code generator following the AAPCS64 calling convention.
• Mach-O object and executable writers, including TLV thread-locals,
  LC_UUID, and ad-hoc code signing.
• An internal AArch64 assembler, so the backend doesn't depend on Apple's
  toolchain to produce object code.
• A self-cross-compile push: teaching the arm64 backend enough of the
  compiler's own feature surface (generics, interfaces, jumbo sets, closures)
  to compile increasingly large slices of Blaise's own source.

On-device bring-up has already reached the point where hello-world,
class-based programs, and even the compiler's own TestRunner run on real
Apple Silicon hardware, with the majority of the suite reaching a clean
summary. There's more to do — full debugger (OPDF) support on arm64 and
broader e2e coverage are next — but the foundation is solid and the pace of
fixes has been fast.

🛡️ BlaiseGuard — a new static analyser, built on your compiler

This cycle also introduced BlaiseGuard, a static analyser purpose-built
for the Blaise dialect. It reuses the compiler's own lexer, parser and AST —
so it always understands exactly the grammar your compiler accepts, with no
vendored copy to drift out of sync.

It already ships rule families for unused identifiers, reference cycles,
risky string indexing, duplicate detection, and several classes of defect
the compiler itself silently accepts today, plus project-level configuration
and inline suppression comments to keep false positives low.

BlaiseGuard isn't bundled in the release tarball yet — it's evolving fast,
so for now build it straight from source:

pasbuild compile -m blaise-guard --compiler <your-blaise-binary>

For a more in-depth look, see here.

✨ Language: operator overloading and compile-time embedding

Operator overloading landed end-to-end this cycle — parse, resolve, and
lower:

type
  TVec2 = record
    X, Y: Double;
    class operator Add(const A, B: TVec2): TVec2;
  end;

class operator TVec2.Add(const A, B: TVec2): TVec2;
begin
  Result.X := A.X + B.X;
  Result.Y := A.Y + B.Y;
end;

Compile-time file embedding also arrived, via {$EMBED} (byte array) and
{$EMBEDSTR} (string):

const
  Greeting: string = {$EMBEDSTR 'greeting.txt'};
begin
  WriteLn(Greeting);   { the file's contents, embedded at compile time }
end.

Other language wins: subranges of enumerated types now work as expected
(TWeekday = Mon..Fri), Boolean is accepted as an array index type, and a
varargs directive lets you bind C-variadic external functions.

type
  TDay = (Mon, Tue, Wed, Thu, Fri, Sat, Sun);
  TWeekday = Mon..Fri;
var
  D: TWeekday;
begin
  for D := Low(TWeekday) to High(TWeekday) do
    WriteLn(Ord(D));
end.

🔧 Toolchain: leaner linking, no more archive

The link model got smarter: Blaise now defaults to a freestanding,
libc-free binary and only pulls in dynamic linking and libc when your code
actually asks for it (an external binding, a bare libc symbol). --static
and --dynamic remain available to force either mode explicitly.

We also removed the blaise_rtl.a archive and its build machinery
entirely — the compiler now source-builds the runtime on demand, cached
per target, so there's nothing to install or keep in sync before a build.

🧮 A pure-Pascal libm — no more libm link dependency

Blaise binaries no longer link libm, because there's no longer anything in
libm left to call. We ported the transcendental math functions Blaise
uses — Sin, Cos, Tan, Exp, Ln, Power, Sqrt and friends —
straight from musl libc's fdlibm-derived math sources into pure Pascal,
living entirely in the RTL:

var
  R: Double;
begin
  R := Sin(1.5707963267948966);
  WriteLn(DoubleToStr(R));   { 1 }
  R := Power(2.0, 10.0);
  WriteLn(DoubleToStr(R));   { 1024 }
end.

Every backend — QBE, native x86-64, and native arm64 — now lowers straight
to these RTL routines, so results are bit-identical across Linux, FreeBSD
and macOS, and accuracy is pinned at ~1 ulp against roughly 190 glibc
reference vectors. It also means --static freestanding binaries can now
use Power and friends for the first time — there was no way to statically
link libm before this.

📚 Standard library

stdlib grew a backtracking regular-expression engine (Text.Regex),
.From([...]) constructors for lists, sets and dictionaries, a TUuid
value type, and AssertRaises/AssertNotRaises in the testing framework —
alongside a steady stream of collection correctness fixes.

🐛 Hardening

A large share of this cycle's commits were bug fixes — many surfaced by the
arm64 self-cross-compile push, which exercised code paths the QBE-only test
harness had never touched. ARC correctness (static arrays of managed
fields, interface pointee reads/writes, unit-global finalisation), jumbo-set
element access, nested-procedure variable capture, and field-array l-value
handling each got a dedicated fix cluster across both backends. Ten GitHub
issues were closed this cycle: #160, #180, #182, #187, #188, #189, #191,
#195, #196, and #208. As well has over 40 bug fixes from my private
collection. :)

⚡ Performance

The native backend picked up register promotion, loop rotation, and a
ported inliner, plus the stack-machine expression idiom was eliminated from
the x86-64 emitter in favour of direct register allocation.

By the numbers

• 415 commits since v0.13.0
• Fixpoint verified on 637,968 lines of QBE IR — stage-2 and stage-3 IR
  byte-identical, alongside green native, internal-assembler and
  warm-cache fixpoints
• 4,977 tests passing (2 ignored), up from 4,275+ last release

Try it

Grab the self-contained Linux or FreeBSD tarball from the
GitHub Releases page
— each bundles the RTL and stdlib source plus a ready-to-go config, so
./blaise --source hello.pas --output hello just works straight out of the
archive.

See the full changelog for the complete technical
rundown.

Donations

If you enjoy following this project, consider donating via Github or Patreon - all donations received goes straight to my sports car into the development and upkeep of this project. 😉

Onwards to v0.15! 🙌

---

Built with ❤️ for the Pascal community.

[rchastain2]

Regular expressions? That's great news!

[spostma679]

Thank you Graeme for all your amazing skilful work and for your persistence!

Blaise is quickly becoming a crown jewel in the Wirth universe...