Performance

minc compared with clang and MSVC on the box3d benchmark suite.

box3d is a 3D rigid-body physics engine: fifty source files of mostly float math and SIMD C, with a benchmark suite of eleven scenes. The C compilers build the upstream source. The minc compiler builds box3d-minc, generated from the same source by a C-minc-transpiler written in minc. All builds emit similar 128-bit SIMD code.

Wall-clock milliseconds per scene, single-threaded, lower is better.

Windows x64

Across the suite minc is 1.18× clang and 1.05× MSVC. It matches or beats clang on the stacking scenes, beats MSVC on three of the eleven, and trails most on the mesh-collision (trees) scenes.

With the solver spread across worker threads the three compilers scale together. Scaling is against the same compiler's own single-worker total.

The vs columns are geomeans over the eleven per-scene paired ratios at that worker count. Scaling flattens the same way for all three compilers: box3d's step has serial phases, so the ceiling is the engine. The gap narrows slightly at eight workers.

macOS arm64

The same eleven scenes on an Apple M1, against Apple clang.

minc is 1.20× Apple clang, matching the Windows figure, and the scene ordering is also similar.

At 2, 4 and 8 workers the ratio stays within 0.02× of the single-worker figure, and minc's thread pool scales like clang's. Totals sum all eleven scenes; scaling is against the same compiler's own single-worker total.

Eight workers adds little over four: the M1 has four performance cores and four efficiency cores. The 8-worker row is also the noisiest, with 11.7% spread at the 90th percentile against about 1% for the others.

WebAssembly

The same eleven scenes compiled to WebAssembly and run in Node on the Windows machine: minc builds the published modules with --target wasm, emcc builds the upstream C from the same box3d pin. Both emit 128-bit wasm SIMD. Single worker.

minc is 1.30× emcc on wasm, with the same shape as the native tables: stacking scenes closest, mesh collision the tail. emcc goes through LLVM, so this measures minc's wasm backend against the same optimizer clang uses natively.

Test setup

Notes

• Method. Every binary runs a given scene back-to-back with the others, so a comparison pair is seconds apart. Each binary and scene gets one discarded warm-up run, then three timed rounds. The millisecond columns show the fastest round. The ratio columns show the median of the three per-round paired ratios, which cancels machine drift. Dividing the millisecond columns gives a slightly different number; the two methods agree to within 0.03× on every scene. On wasm each sample additionally takes the fastest of four in-process runs, the upstream driver's own default; a fresh process's first run carries V8 tier-up, which reads as a 2× slowdown on the shortest scene and is compile time, not generated code. Run-to-run spread at the 90th percentile is 2.1% on Windows, 1.0% on macOS and 3.4% on wasm. Ratios within a few percent of 1.00× are parity.
• /fp:contract is required for a fair MSVC comparison. minc fuses multiply-add unconditionally and clang contracts by default. MSVC keeps multiply and add separate under /O2 /arch:AVX2 alone, and measures about 10% slower without /fp:contract.
• minc emits no automatic 256-bit SIMD. The x64 references use ymm mostly as a copy width: about 1,900 ymm instructions in the clang binary and 2,200 in MSVC, dominated by 32-byte vmovups, against zero in minc. clang also vectorizes a few float loops to 256-bit. MSVC keeps float math at 128-bit. minc's vector types currently cover explicit 256-bit SIMD only. Box3d's own 128-bit SIMD path, used on both platforms, compiles in full.
• Bounds checking is enabled in minc. The C columns run unchecked.
• Single-threaded. box3d can spread the solver across workers, but the per-scene tables use one worker. The scaling tables cover 2, 4 and 8 workers on both machines; the ratios hold or narrow as workers are added.
• This is one benchmark suite, and work in progress. Physics is float- and branch-heavy and leans on struct-by-value math. Other workloads will show different ratios.

Questions, or a workload where minc does noticeably worse? Open an issue.