Projects

The application is ManimStudio — also on this page — 10,100 lines with pywebview, Pillow and pyobjc. Built both ways on the same machine, interleaved so drift falls on both equally. Every row is scaled to its own maximum and labelled with the real figure.

Compile time: 16.7 s against Nuitka's minutes — left out of the figure above because “minutes” is not a number to scale a bar against. Nuitka wins the fourth row, and the binary is a third the size because Nuitka compiles every module it reaches while this compiles the program and ships its dependencies as bytecode — 7.8 MB of it, which is where most of the 20 MB comes back.

Speed is one question; agreeing with CPython is the other, and here Nuitka is ahead. Seventy-eight whole programs compiled by both, each output compared with what CPython answers for the same source — stdout and exit code, character for character, same machine for all three columns.

It should be ahead: it is a mature project that reimplements CPython's semantics rather than restricting them. Most of the gap is one fact and its consequences — a compiled function here is a builtin_function_or_method, so it has no code object and builds no frame, which is exactly what makes a direct call 2.4× faster and what costs it sys._getframe, tracebacks naming a source line, and inspect.getsource. Two of the differing rows are not a py2bin problem at all: neither compiler reports function for type(f).__name__, and neither has bytecode to hand back. One goes the other way — except* agrees with CPython on 42,100 shapes here and Nuitka answers differently. A corpus covers what somebody thought of, so 1,500 programs drawn at random from the grammar were compiled and compared too: 1,494 match exactly and none is refused, the six that differ all printing a function object. Every number on this page was measured locally rather than read off a green tick: the repository's workflow runs the suite on three operating systems and three Pythons, the corpus on Linux and a cross-build for all six targets, but it has never actually executed — runs queue on that account and never start.

Run time is what you wait for; build memory decides whether the build runs at all. py2bin writes the machine code, the object file and the container in Python and never starts a C toolchain — Nuitka writes C and hands it to clang. Cold is a first build or a CI runner; Nuitka keeps a ccache, py2bin has no build cache of any kind, so its column is the same either way.

The advantage narrows as the program grows, and by three thousand functions it is gone. Nothing here streams — the whole module is held as objects, then as C, then as machine code, all at once — so memory grows with the program, while Nuitka's is dominated by a fixed toolchain cost. That toolchain is counted, and it is most of Nuitka's column: on a small program its tree holds clang at 181 MB and ld at 150 MB beside Python's 300; at three thousand functions ld alone holds 1,210 MB. py2bin's tree holds one Python process and nothing else. The artifact starts in 10.1 ms from 49 KB, against CPython's 13.8 ms and a Nuitka --standalone's 15.4 ms from 17.2 MB.

Loops win; calls do not — and the reason is worth stating rather than hiding. Since 3.11 CPython rewrites hot instructions into specialised forms, so a + between two ints never reaches PyNumber_Add. Emitting a generic C-API call for every operation produces exactly the code the interpreter has learned to avoid. So py2bin does what CPython does: a local the analysis can claim is held in a machine register, with an overflow check that falls back to unbounded arithmetic when the value leaves the word — 3 ** 200 compiled this way is still exact. Calls still lose, and will until a calling convention passes a machine integer as one; today an argument is boxed at the call and unboxed inside.

There is no import ctypes anywhere on that path, which a test asserts by compiling in a fresh interpreter and listing what got loaded. ctypes is standard library and would pass an imports-only-stdlib check, but it pulls in subprocess — and there are Pythons, the one on a phone among them, where a subprocess is not something a program may have.