Browse the documentation

Early preview

Performance specifications

These are the Executor's performance specifications: the design targets the Executor is built to, each with the exact conditions it is stated for. They are targets from the Executor's requirements, not measured results.

The specifications

AreaDesign targetConditions
Supervisor binary overheadLess than 3.0 MB (core variant); less than 6.0 MB (extended variant)Stripped static Rust supervisor overhead per wrapped executable. The extended variant adds the message brokers, the webhook, the auto-scaler and the load balancer.
Warm startup overheadLess than 15 msWrapped native Go or Rust binaries, and warm-cached Python or JVM workloads.
Cold startup overheadUnder 350 msThe first run, with cold runtime-cache extraction.
Supervisor footprintLess than 6 MB RSS and less than 0.1% CPUAt a one-minute HTTP exit-event polling interval, for the core variant with no load-balancer connections.
Immediate stop latencyUnder 5 msFrom exit-event evaluation to complete process-tree termination in IMMEDIATE mode, across 50 concurrent child worker processes.
Strict CPU cap accuracyNever more than 2% over the limitCPU usage of the capped tree over any one-second window, with kernel enforcement.
Strict memory cap accuracyNever over the limitMemory usage of the capped tree, with kernel enforcement. Percentage limits resolve exactly: 10% of 10 cores is 1.0 core.
Load-balancer latencyLess than 1 ms added median latencyPer proxied connection on loopback.
Load-balancer memoryLess than 20 KB per idle connectionSupervisor memory per idle proxied connection in tcp mode.
Scale-out reactionNew replica launched within 1 s; traffic within 100 msLaunch counted from the end of the scale-out window; traffic counted from the replica passing its readiness check.
IntegrityAny byte change fails verificationAny modification to the supervisor, the embedded policy or the bundled runtime archive fails BLAKE3 and Ed25519 verification before the guest starts.

How the design meets the targets

  • Small binaries. The supervisor is compiled with lto = "fat", codegen-units = 1 and panic = "abort" against musl on Linux and the static CRT on Windows. Unlike runtimes that bundle a garbage collector, it adds only the supervisor itself, and it runs inside FROM scratch images. The smallest variant that satisfies the manifest is always chosen; see Supervisor variants.
  • Fast starts. Interpreted runtimes are extracted once into a content-addressed, read-only runtime cache and reused on every later start.
  • A quiet supervisor. A single-threaded asynchronous event loop multiplexes polling, monotonic timers, the checkpoint socket and the child wait queues (pidfd on Linux, I/O completion ports on Windows, kqueue on macOS), with negligible idle CPU.
  • Fast, complete stops. The whole process tree is terminated through one kernel object: cgroup.kill on Linux, TerminateJobObject on Windows.
  • Accurate caps. Caps are enforced by kernel primitives on the cgroup or Job Object that holds the whole tree: cpu.max and memory.max with swap disabled on Linux, Job Object limits on Windows.
  • Lightweight balancing. The load balancer runs on the supervisor's event loop, not as a separate process.