Performance Notes​

How fast JaiScript is, what fast script looks like, and how to measure it. This is the one page on the site that holds benchmark numbers.

The headline​

Whole programs, each written the ordinary way in every language, hash-checked against each other, timing their own workload so start-up and compilation stay out. Lower is faster; the last column is the VM's time over Lua 5.4's.

The pattern: typed loops over locals and typed arrays run level with or ahead of Lua; programs made of many small calls over shared objects take about 2.4 to 2.7 times Lua's time. Per-call and per-object cost is the VM's slowest ground. The four app rows are medians of seven interleaved processes; the game rows are detailed below.

Kernels and microbenchmarks​

The kernel suite. Over the sixteen interpreter kernels of daScript's dasProfile, run under its protocol (one process per sample repeating the kernel for 0.5 s, median of five, implementations interleaved, checksums equal), idiomatic typed JaiScript takes a geometric mean of 1.09× Lua 5.5.1's time, and the same algorithms with var everywhere 1.35×.

Microbenchmarks, µs per iteration, fastest of five runs:

This harness prints whole microseconds, so it resolves only the rows above. Method invocation, class creation, array push/pop and map insert-and-lookup print 0 for the VM, 1 to 2 for Lua, 2 to 3 for Squirrel and 10 to 17 for ChaiScript: that orders the runtimes and gives no ratio. What the table does show is Lua ahead on the tight loop (about 3×), call-dense recursion (2.8×) and the script-built tree (2.3×), Squirrel ahead on the last two (1.25× and 1.6×), and ChaiScript 12 to 19 times slower wherever it runs.

Whole games​

Measured 2026-11-04 on the reference machine; every run's frame or state hash matches across runtimes. Each row is the median of three to six runs, the builds interleaved. Small differences are code layout, not speed: relinking the same program with unused padding moves most rows by under 2%, OSSUARY's serial row and GLOOM's parallel row by up to 9%, and LuaJIT's by over 20%.

LuaJIT's JIT generates machine code at run time, which some shipping targets (iOS) forbid: it is a ceiling, not a target. Style is nearly free: a flat rewrite of GLOOM in free functions and globals produces identical hashes and runs within 2% of the class-based version, so choose the architecture you want to maintain.

Patterns that matter​

// The fast shape: typed locals, typed arrays, & params, compound element stores.
array<int> pix = [];
for (int i = 0; i < 64; ++i) { pix.push(0); }

function shade(array<int>& dst, int base) {      // & = no copy, writes land in the caller
    for (int i = 0; i < dst.size(); ++i) {
        dst[i] += base + (i & 7);                // compound element store: one fused op
    }
}

shade(pix, 100);
int sum = 0;
for (int i = 0; i < pix.size(); ++i) { sum += pix[i]; }
print("sum = {}", sum);

function square(int x) { return x * x; }
array<int> nums = [];
for (int i = 1; i <= 8; ++i) { nums.push(i); }
var squares = parallel_transform(nums, square);   // deterministic at any worker count
print(to_json(squares));

sum = 6624
[1,4,9,16,25,36,49,64]

In priority order:

1. Declare types. int, float and auto locals take the typed fast paths; var is the dynamic opt-out and costs accordingly (1.09× against 1.35× Lua on the kernel suite).
2. Pass and hold anything heavy by &. Assignment and by-value parameters copy, as in C++. A copy that is only read binds in place for free, but treat that as a bonus (Value Semantics). Walk containers with for (auto& u : units).
3. Use array<int> and array<float> for bulk numeric data. Same API, raw primitive storage: a 13,600-element grid takes 109 KB instead of 435 KB, a copy is a memcpy, and element access skips boxing.
4. Write compound element stores. a[i] += v is one instruction, cheaper than the spelled-out read and write.
5. Keep calls out of the innermost loop. A call costs about ten fused loop iterations. A self tail call (return f(args)) is the exception: it reuses the frame (about 40 ns a call) and runs at any depth.
6. Parallelize the bulk stages. parallel_for and parallel_transform run bodies the engine proves safe on a worker pool, with identical results at any worker count.
7. Define classes once. Executing a class declaration does redefinition and hot-reload bookkeeping (about 250 µs for a 30-line class script on the report machine). Per-frame scripts call; they do not declare.
8. Reuse engines. Creating one and registering the stdlib costs hundreds of warm executes.

Strings need no builder: s += x, s = s + a + "-" + b, template strings and format() append into the string's own buffer, amortized O(1), whether s is a local, a global, a field, an element or a string& parameter.

What is slower, and what to use instead​

The cost model for embedders​

What an operation costs​

Report machine, VM, Release. Use the orders of magnitude.

Compilation costs about a third of parsing and is cached with the parsed source, so a repeated script pays both once. The automatic jaibite disk cache makes file loads IO-bound: a 535-line game file's load-and-run drops from 5.8 ms to 2.4 ms.

What each aliasing strategy costs​

One computation over a mid-sized object (a string, an 8-int array, 4 scalars), VM, µs per call, report machine:

On the 15-node BST, & parameters run 1.35× faster than returning and reassigning a shared_ptr, and both about 3.5× faster than by value.

What the debugger costs​

The 1000-iteration hot loop, VM, report machine, µs per run:

The debugger is free until a session arms, then costs about 10%. The last row is the worst case: one string compare per line-number collision.

Measuring yourself​

1. Release only. A Debug build of the engine runs script 25 to 40 times slower.
2. Pin to one core, interleave the builds you compare, take the median of five or more, and check that every run prints the same result hash.
3. Time the workload inside the script after a warm-up, so start-up and compilation stay out.
4. Distrust small deltas. A change smaller than a relink's spread (2% on most programs) is code layout.

The ports of these programs to Lua, Squirrel, Luau and ChaiScript and the harness that drives them are not part of the JaiScript package, so the package reproduces the JaiScript column of every table and not the others.