README

Better Pascal (bp)

The philosophy of Better Pascal: the simplicity of development of Go with the performance and reliability of Rust. Take the best of Go (memory safety, code that is simple to write and for a model to generate, build speed, performance, goroutines, light dependencies) and replace the unpredictability of a collector with the determinism of owners and regions, in a way that needs no lifetime annotations written by hand: everything is to be inferred. Whether the reliability of Rust can be reached this way is an open question, and the study of its feasibility is one of the goals of the project. The performance and the reliability of Rust are the goal the work moves towards, measured as it goes.

Research questions. Better Pascal is also research in programming languages. It tests these hypotheses:

1. Memory safety without changing the compiler: how far a library and a check before the build over the stock compiler can go.
2. The reliability of Rust without lifetime annotations: whether everything can be inferred without rejecting too many correct programs.
3. The speed of C without annotations and without a collector: whether there is a way besides the regions and root analysis of Goose: the choice of algorithm and memory in the library (the memory manager, vector kernels, string views).
4. Several safe memory models in one language (owners, regions, arenas, a collector): whether the choice helps a model pick the approach that fits a task, or harms, and one or two main styles should stay.

Each hypothesis is tested by measurements and tests: the table of guarantees (§8), the benchmarks (§25.2), findings such as H20. A "no" is a result too.

Build with tools/bp build, not with fpc directly. bp build [--release] [fpc options] FILE.pas checks the program (bpvet --strict --typed: ownership, regions, borrows) and calls fpc only when the check passes, so unsafe code is built only where it is declared (// UNSAFE:, // borrow:, // root:). The guarantees of Better Pascal are the guarantees of bp build; a cached check takes about 30 ms. bp run FILE.pas [args] runs it (a file with #!/usr/bin/env -S bp run is a script), bp new NAME starts a project.

In numbers, against C, Rust, Go and Goose (one machine, medians; the scripts and the verdicts: tests/bench/size.sh and safe/SPEC.md §25.5, tests/bench/compare.sh and §25.2, the plan: unxed/bp#181):

• Ahead: the memory of a program, the start (all but static C), the size among static binaries, one static file that runs on any Linux.
• Reaching:
  • the rebuild: on a small program the level of gcc (hello world after an edit: Bp 144 ms, gcc 66 ms, Go 204–230 ms); on a project of many files the level of gcc and ahead of Go (20 files, 17 thousand lines, after an edit of one: Bp 248 ms, gcc 260 ms, Go 349 ms; a clean build: Bp 718 ms, the fastest, gcc 2.7 s, Go 6.9 s; tests/bench/project.sh);
  • the run time: the gap to C is not in the language (typed, compiled, no collector, the class of C) but in the optimizer of FPC (tickets upstream, #185; Bp stays on the releases of FPC and its usual back end) and the map and strings of BP; §25.2 splits it;
  • the memory manager of BP is on by default (BP_HEAP=rtl for the heap of the RTL); goroutines run M:N on a few carriers by default (BP_MN=0 for one OS thread per task).
• Accepted as the niche: a dynamic binary over glibc is smaller, but runs only where that glibc is.

How it compares (built with bp build; measured 2026-11-04, details in unxed/bp#108 and safe/SPEC.md §20):

The Lazarus LCL is not yet tested with bp build; the TComponent tree is an owner in the typed bpvet (TFoo.Create(AOwner) and the published component fields of a form need no marks, safe/SPEC.md §21.4), checked on a form-like unit with a stub of the hierarchy. The plan of concept v3 (one scope object, Send and Sync inferred, goroutines M:N, the TComponent tree as an owner) and what is reused from which language: safe/SPEC.md §21. What the tools still lack against go, cargo and zig (bp run and scripts, --watch, cross targets, tests with a leak check, // derive:, a profiler, an editor server, a page in the browser): safe/SPEC.md §22. The fresh look of concept v4 (one sentence for all lifetimes, marks of fact written by the machine, BP last in the program file too, what FPC 3.2 already ships and the dialect had not used, the casts and the uninitialised variables that §8 missed): safe/SPEC.md §24.

Try it: an HTTP/1.1 server on goroutines, with the scratch of each request in a region (examples/httpd/README.md):

tools/bp build -Futools/spikes/region -FEout examples/httpd/httpd.pas
out/httpd 8080 &
curl 'localhost:8080/json?n=5'

On /, with ab -k -c 64 on a 4 vCPU runner (2026-11-04), it serves 63917 requests per second; the same server in Go 74685 and in Rust (the standard library, a thread per connection) 63758.

Free Pascal as one would want it by default: safe memory, UTF-8 everywhere, goroutines. No FPC fork and no compiler options: a single unit BP gives all of it.

program Hello;
uses BP;   // BP goes last in every uses; tools/bp build adds -FaBPThreads (the thread manager first)
begin
  WriteLn('Hello, world 😀', CPLength('aё😀'));
end.

In all other units BP is listed last in uses: this way it shadows the dangerous primitives (GetMem(...) does not compile, System.GetMem is an explicit unsafe). The compiler needs the unit paths: fpc -Fu<path> -Fu<path>/safe -Fu<path>/ext, where <path> is the directory of bp.pas.

What BP gives

unit Safe (safe/safe.pas) is the safe layer alone. ext/fpc-utf8/ is a separate UTF-8-only variant for code that does not use BP (a unit inserted with -Fa).

Linux builds are static and need no libc by default; -dSAFE_LIBC switches to libc (cwstring, cthreads), needed only for FFI with C libraries. -dSAFE_NO_UTF8 turns off the UTF-8 defaults. The specification: safe/SPEC.md.

Dependencies (safe/SPEC.md §15, Go modules with git as the registry): write require github.com/acme/json v1.4.0 into deps.txt next to the program, run tools/bp get (it writes deps.lock with the commit of each version), then tools/bp build FILE.pas finds the units; tools/bp vendor copies them into vendor/. A library is a git repository with a tag vX.Y.Z and a deps.txt with its module line; this repository is github.com/unxed/bp.

Layout

tests/run.sh all builds every test with no compiler options except the unit paths: the safe layer twice (with Safe and with BP), the ext layer with BP, ext/fpc-utf8, and checks that bp.pas includes every file of unit Safe. The Pascal examples of the documents are compiled and linted by tools/doctest.py in CI.

Licences

bp.pas, safe/, ext/, tests/: MIT (LICENSE). fpide/: GPL (see fpide/README.md).

The repository is still called sp; renaming it to bp is up to the owner.