Beyond
the Editor

Same job. Python vs C. Run it.

terminal · demo/
$ ./run.sh
cpu: Intel(R) Xeon(R) Processor
N = 100000000
python 12750000000 5.241 s
c      12750000000 0.025 s
C is 210x faster
210×
add up 100 million numbers

Captured 18 Nov 2026 · Intel Xeon (KVM VM, 8 vCPUs) · Python 3.13.5 · gcc 14.2 -O2

Line for line, the same loop.

sum.py
import sys, time
N = int(sys.argv[1])
t = time.perf_counter()
total = 0
for i in range(N):
    total += i & 255
dt = time.perf_counter() - t
print(f"python {total} {dt:.3f} s")
sum.c · gcc -O2
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main(int argc, char **argv) {
    long n = atol(argv[1]);
    clock_t t = clock();
    long total = 0;
    for (long i = 0; i < n; i++)
        total += i & 255;
    double dt = (double)(clock() - t) / CLOCKS_PER_SEC;
    printf("c      %ld %.3f s\n", total, dt);
}

a + b in C: 1 line. In Python: 66.

C · gcc 14.2 -O2
int add(int a, int b)
{ return a + b; }

lea  eax, [rdi+rsi]
  ; eax = a + b (1 cycle)
ret
  ; back to caller (2 cycles)
inlined into a caller
add  edi, esi
  ; a + b, inlined (1 cycle)
CPython 3.13 · objdump of the real binary
endbr64                   ; landing pad (0 cycles)
mov  r9, [r15-16]         ; left = stack[-2] (4 cycles)
mov  r12, [r15-8]         ; right = stack[-1] (4 cycles)
mov  [rbx+56], rbp        ; save bytecode ptr (1 cycle)
add  rbp, 4               ; next bytecode (1 cycle)
cmp  [r9+8], &PyLong_Type ; left is an int? (5 cycles)
jne  deopt                ; no: slow path (1 cycle)
cmp  [r12+8], &PyLong_Type; right is an int? (5 cycles)
jne  deopt                ; no: slow path (1 cycle)
mov  rdi, r9              ; arg 1 = left (0 cycles)
mov  rsi, r12             ; arg 2 = right (0 cycles)
mov  [rsp], r9            ; spill left (1 cycle)
call _PyLong_Add          ; do the add (2 cycles)
endbr64                   ; landing pad (0 cycles)
push r12                  ; save register (1 cycle)
mov  rdx, rsi             ; copy right (0 cycles)
push rbp                  ; save register (1 cycle)
push rbx                  ; save register (1 cycle)
mov  rax, [rdi+16]        ; left size/sign (4 cycles)
mov  rcx, [rsi+16]        ; right size/sign (4 cycles)
mov  r8, rax              ; copy tag (0 cycles)
mov  rsi, rcx             ; copy tag (0 cycles)
or   rax, rcx             ; merge both tags (1 cycle)
and  r8d, 3               ; left sign bits (1 cycle)
and  esi, 3               ; right sign bits (1 cycle)
cmp  rax, 15              ; both one digit? (1 cycle)
ja   big_add              ; no: big-int add (1 cycle)
mov  eax, 1               ; eax = 1 (1 cycle)
mov  edx, [rdx+24]        ; right digit (4 cycles)
mov  rbx, rax             ; rbx = 1 (0 cycles)
sub  rax, r8              ; left sign (1 cycle)
sub  rbx, rsi             ; right sign (1 cycle)
imul rbx, rdx             ; right, signed (3 cycles)
mov  edx, [rdi+24]        ; left digit (4 cycles)
imul rax, rdx             ; left, signed (3 cycles)
add  rbx, rax             ; << THE ADD: a + b (1 cycle)
lea  rax, [rbx+5]         ; result + 5 (1 cycle)
cmp  rax, 261             ; in -5..256? (1 cycle)
ja   new_int              ; no: allocate (1 cycle)
lea  ebp, [rbx+5]         ; cache index (1 cycle)
movsxd rbp, ebp           ; widen index (1 cycle)
shl  rbp, 5               ; x 32 bytes (1 cycle)
add  rbp, small_ints      ; cached int (1 cycle)
mov  rax, rbp             ; return value (0 cycles)
pop  rbx                  ; restore (1 cycle)
pop  rbp                  ; restore (1 cycle)
pop  r12                  ; restore (1 cycle)
ret                       ; back to handler (2 cycles)
mov  r9, [rsp]            ; reload left (4 cycles)
mov  r13, rax             ; keep result (0 cycles)
mov  rax, [r12]           ; right refcnt (4 cycles)
test eax, eax             ; immortal? (1 cycle)
jns  decref_right         ; no: decrement (1 cycle)
mov  rax, [r9]            ; left refcnt (4 cycles)
test eax, eax             ; immortal? (1 cycle)
jns  decref_left          ; no: decrement (1 cycle)
test r13, r13             ; add failed? (1 cycle)
je   error                ; yes: raise (1 cycle)
movzx eax, [rbp]          ; next opcode (4 cycles)
mov  [r15-16], r13        ; push result (1 cycle)
sub  r15, 8               ; stack - 1 (1 cycle)
movzx ecx, ah             ; its argument (1 cycle)
mov  r13d, eax            ; keep opcode (0 cycles)
movzx eax, al             ; its opcode (1 cycle)
movsxd r11, ecx           ; widen arg (1 cycle)
jmp  [targets+rax*8]      ; dispatch (1 cycle)

Casey measured the same gap, tuned all the way.

0.006
adds / cycle · plain Python
vs
52
adds / cycle · C, SIMD, 4 cores

≈ 8,700× on the same chip

Data-oriented: the whole game on one page.

input→steer→move→shoot→compact→wave→draw
// arena.c: a wave shooter, data-oriented. gcc -O2 arena.c -lraylib -lm
#include "raylib.h"
#include <math.h>
#define MAX 4096                      // where there is one, there are many
static float ex[MAX], ey[MAX];        // positions: one array per field
static float vx[MAX], vy[MAX];        // velocities: their own arrays
static unsigned char alive[MAX];      // 1 byte per enemy, packed
static int count, wave;
static void spawn_wave(void) {
    wave++;
    count = wave * 64 < MAX ? wave * 64 : MAX;
    for (int i = 0; i < count; i++) {
        float a = i * 2.39996f;       // golden angle: a ring of enemies
        ex[i] = 640 + cosf(a) * 600;
        ey[i] = 360 + sinf(a) * 340;
        vx[i] = vy[i] = 0;
        alive[i] = 1;
    }
}
int main(void) {
    InitWindow(1280, 720, "Arena, data-oriented");
    SetTargetFPS(60);
    float px = 640, py = 360;         // one player: plain scalars
    spawn_wave();
    while (!WindowShouldClose()) {
        float dt = GetFrameTime();
        px += (IsKeyDown(KEY_D) - IsKeyDown(KEY_A)) * 300 * dt;
        py += (IsKeyDown(KEY_S) - IsKeyDown(KEY_W)) * 300 * dt;
        // steer: reads ex, ey; writes vx, vy. Nothing else.
        for (int i = 0; i < count; i++) {
            float dx = px - ex[i], dy = py - ey[i];
            float k = 400 * dt / sqrtf(dx * dx + dy * dy + 1);
            vx[i] = vx[i] * 0.98f + dx * k;
            vy[i] = vy[i] * 0.98f + dy * k;
        }
        // move: four arrays, front to back, no pointers
        for (int i = 0; i < count; i++) {
            ex[i] += vx[i] * dt;
            ey[i] += vy[i] * dt;
        }
        // shoot: hold the mouse to kill enemies near it
        if (IsMouseButtonDown(MOUSE_BUTTON_LEFT)) {
            Vector2 m = GetMousePosition();
            for (int i = 0; i < count; i++) {
                float dx = m.x - ex[i], dy = m.y - ey[i];
                if (dx * dx + dy * dy < 40 * 40) alive[i] = 0;
            }
        }
        // compact: copy the living to the front
        int n = 0;
        for (int i = 0; i < count; i++) {
            if (!alive[i]) continue;
            ex[n] = ex[i]; ey[n] = ey[i];
            vx[n] = vx[i]; vy[n] = vy[i];
            alive[n++] = 1;
        }
        count = n;
        if (count == 0) spawn_wave(); // last one fell: next wave
        BeginDrawing();
        ClearBackground((Color){ 10, 13, 15, 255 });
        for (int i = 0; i < count; i++)
            DrawRectangle(ex[i] - 4, ey[i] - 4, 8, 8, ORANGE);
        DrawCircle(px, py, 12, GOLD);
        DrawText(TextFormat("wave %d  alive %d", wave, count), 20, 20, 30, RAYWHITE);
        EndDrawing();
    }
    CloseWindow();
}

An agent wrote the game and the test.

const game = newMatch();
const limit = Math.ceil(300 / STEP);
for (let t = 0; t < limit && game.winner < 0; t++)
    stepMatch(game);

assert.equal(game.score[game.winner], 10);
const final = [...game.score];
stepMatch(game);
assert.deepEqual(game.score, final);
The Pong bot match running in the browser
10–5
3,585 ticks · then the score freezes

Start from a template. Hand the agent the docs.

PixiJS examples page: sprites, SVG and texture examples

PixiJS · 2D

npm create pixi.js@latest

docs for the agent → pixijs.com/llms.txt
three.js examples page running the Littlest Tokyo animation example

three.js · 3D

npm install --save three

docs for the agent → threejs.org/docs/llms.txt
GitHub page of raysan5/raylib-game-template, a public template repo

raylib · C

raysan5/raylib-game-template

docs for the agent → raylib.com/cheatsheet

raylib: the examples are the docs.

#include "raylib.h"
int main(void)
{
    InitWindow(800, 450, "raylib [core] example - input keys");
    Vector2 ballPosition = { 400.0f, 225.0f };
    SetTargetFPS(60);
    while (!WindowShouldClose())
    {
        if (IsKeyDown(KEY_RIGHT)) ballPosition.x += 2.0f;
        if (IsKeyDown(KEY_LEFT)) ballPosition.x -= 2.0f;
        if (IsKeyDown(KEY_UP)) ballPosition.y -= 2.0f;
        if (IsKeyDown(KEY_DOWN)) ballPosition.y += 2.0f;
        BeginDrawing();
            ClearBackground(RAYWHITE);
            DrawCircleV(ballPosition, 50, MAROON);
        EndDrawing();
    }
    CloseWindow();
}

Official example core_input_keys, trimmed

raylib example core_input_keysraylib example models_first_person_mazeraylib example core_2d_camera_platformerraylib example textures_bunnymarkraylib example shaders_raymarching_renderingraylib example models_heightmap_renderingraylib example shaders_cel_shadingraylib example models_animation_blending

223 small examples,
one idea each

raylib.com · plain C99 · zlib licence

Three kinds of muscle.

Single thread

one lane

SIMD

8–16 lanes per core

GPU

thousands of lanes

Math you can do in one frame · 16.7 ms · FP32 peak

106
108
1010
1012
Python loop · 1 core
560 K
1 Zen 4 core · scalar
373 M
Raspberry Pi 5 · 4 cores NEON
2.56 G
1 Zen 4 core · AVX
2.99 G
12 Zen 4 cores · AVX
30.1 G
Radeon 780M iGPU
74.2 G
RTX 4090
1.38 T
RTX 5090
1.75 T

Theoretical peak from vendor clocks and core counts · Python bar is Muratori's measured rate · log scale

Don't waste compute on the wrong thing.

Single thread

game rules · AI decisions · a few hundred entities

SIMD

particles · physics batches · audio mixing

GPU

pixels · ray tracing (advanced GPUs) · huge particle sims · ML inference
pays for upload, dispatch, readback

Measure first.

Well-optimized apps feel instant.

Illustration: a fingertip nudges a slider and a fire plume reacts instantly

Real example: EmberGen, JangaFX ↗

Their own language, editor and debugger. Live.

One prompt, one scene.

Claude Code in a terminal on the left building a low-poly island with a lighthouse in Blender on the right

Mervin Praison · Claude Code + Blender MCP

Best at building 3D, today · AA-3D Elo, 18 Nov 2026

1 GPT-6.2 Astra (Max) 1318

2 Claude Fable 5.2 (Max, Default Fallback) 1271

3 GPT-6.2 Sol (Max) 1259

artificialanalysis.ai/evaluations/aa-3d Three views of a 3D-rendered aircraft-style instrument panel: a display reading heading 274, HYD and GYRO lamps, NAV, COM and EXT toggles, a TRIM knob

GPT-6.2 Astra, rendered object · credit @davinci_stan666

“Start from an empty scene. Build a small low-poly island at sunset: a lighthouse, a wooden dock with a little boat, a few palm trees, and calm sea around it. Add warm sunset lighting and a camera that frames the whole island nicely. Then render the camera view to ~/blender-demo/island.png and save the file as ~/blender-demo/island.blend.”

Same rules, new seed, new city.

press R for a new seed

Style is a hardware budget.

Tiny Glade: a soft painted stone castle by a pond

Stylized

Tiny Glade · Steam Deck Verified

Ratchet close-up: cartoon proportions, film-like fur and lighting

Stylized realism

Ratchet & Clank: Rift Apart · PS5 · 30 or 60 fps

Senua's face in photoreal close-up

Realism

Hellblade II · Xbox Series X · 30 fps

Same scene. Three shaders.

Ian Curtis (@XRarchitect, World Labs) · three.js · 12 Nov 2026

Math per pixel, every frame.

≈740

Raspberry Pi 5

1080p · 60 fps · estimate

21,000

PS5

4K · 60 fps

26,000

Steam Deck

1280×800 · 60 fps

36,000

Laptop iGPU

Radeon 780M · 1080p · 60 fps

211,000

RTX 5090

4K · 60 fps

Peak GPU FLOP ÷ (pixels × frames per second) · vendor specs · area ∝ budget

A whole game console at 168 MHz.

Playdate: a small yellow handheld with a black-and-white screen and a crank

What

Panic's handheld · $229

Inside

168 MHz Cortex-M7
16 MB RAM

Screen

400×240, 1-bit
and a crank

≈58

CPU cycles per pixel, per frame

Make games

Lua or C, SDK + Simulator

Play this

Mars After Midnight
Lucas Pope

play.date · help.play.date/hardware/the-specs · play.date/dev

32 KB of code.
No 3D engine.
No polygons.

Dash · @creativedash
15 Nov 2026 · playable: remix.ui8.ai/fly

Lucas Martinic · x.com/lucas_martinic

live demo

A student steps out of a small tiled walled garden through an open teal door into a wide wireframe landscape under a sunrise

Watch these next.