Scale measurements

These measurements show how compile, bundle, and run costs grow as ALGAL programs reuse helpers, and the size at which compilation refuses them.

A source project compiles to manifests, the JSON programs that both runtimes execute. A manifest names each child program by digest, so a bundle stores a shared helper once however many places call it. Every call still counts before a run: one compilation may expand to at most 1,024 manifest instances, 4,096 cells, 16,384 edges, and 64 MiB of manifest JSON, counting each call occurrence again. Building larger programs lists these limits beside the source limits. Browser task history is measured separately, because its verification cost grows with saved history rather than with program size.

What the numbers show

The tables report capacity and cost: how far each program grows before a limit refuses it, and what compiling, packing, and running it took on one machine. They say nothing about whether reusing programs improves later work; that is the open cumulative-skill experiment. The generated programs are synthetic shapes, each built to reach one limit.

Reproduce the measurements

From the repository root, with a release build of the native CLI:

cargo build --release --locked -p algal
ALGAL_BIN=target/release/algal bun scripts/measure-source-scaling.ts \
  --markdown --out source-scaling.json
bun scripts/measure-history-scaling.ts --tasks 32 --title-length 120 \
  --out history.json

Each script writes a JSON record with every repetition and prints a table. Without ALGAL_BIN, the native times are omitted. The counts in the first three tables below do not depend on the machine, and bun test scripts/source-scaling.test.ts fails when one of them stops matching a fresh compile and run.

Example projects

Each example project entry point, compiled from its source files and run with its committed fixture:

The task planner's clamp helper is two of its seven instances and one of its six modules, so its bundle is smaller than the manifest bytes the check counts. An each call counts as one instance however many items it runs, so the planner's run activates 92 cells for three tasks while the check counts 34. ratios fails on purpose: its second item divides by zero.

Programs that share helpers

The measurement script also generates projects that call shared helpers from more and more places. It grows each one through 1, 2, 4, and more units until something refuses it, then bisects to the exact boundary. The table shows one unit and the largest size that compiles; the JSON record has every step.

A run activates at most 1,024 cells, while the check accepts up to 4,096. Every row with 1,024 steps passed the check and then stopped at that step limit with BUDGET_EXHAUSTED; of the largest sizes that compile, only import-chain and drafts run to completion.

Where compilation stops

One unit past each boundary, compilation refuses the project. The check stops as soon as one count would pass its limit, before it resolves the rest of the expansion. Instances checked is how many manifest instances it accepted before refusing; Full expansion is the instance count of the complete expansion, computed once per distinct module without building it.

Nine compact-dag files, 13,851 bytes of source, would expand to more than 114 billion instances; the check refuses them after accepting 944. The same message covers the instance, cell, and edge limits, so the Limit column names the count that crossed. import-chain and drafts stop earlier, in the source loader and the source compiler, before any manifest exists. The static depth limit of 64 cannot be reached from source, because source imports stop at eight levels.

Timings

Each time is the median of five repetitions after one warm-up, in milliseconds, with the range in parentheses. The run used an Apple M4 Max with 16 cores and 128 GB of memory, macOS 26.5.2, Bun 1.3.14, and a release build of the native CLI from the same commit. Other work shared the machine throughout, with load averages between 22 and 28 on its 16 cores, so the times are indicative only.

Rows without pack and run times are the refusals from the previous table. Median check times stay under a second. The largest, record-orders at seven regions, checks 120 instances holding 65 MB of manifest JSON in 954 ms, and the refusal at eight regions takes 471 ms of checking. The nine-file compact-dag is refused after 55 ms of checking and 306 ms of source compilation. Run time follows the work a run does more than the program's size: each record-orders call checks and compares sixteen 48 KB orders, so its runs take seconds, while table-fan-in at nine sections reaches the 1,024-step limit in 66 ms.