Hero-filmen i C++. Noll rader för hand.

TokenTeks symbol är en hatt. Inte vilken hatt som helst, utan einstein-plattan: den trettonsidiga form som upptäcktes 2023 och som kan täcka ett oändligt plan utan att mönstret någonsin upprepar sig. Eftersom vi bygger skräddarsytt i stället för att använda mallar passar symbolen bra: en enda form som räcker till oändlig variation.

Den nya webbplatsen behövde en bakgrundsfilm till startsidan. Kraven som sattes på morgonen den 10 juli var korta och tydliga:

• Filmen ska bygga på den riktiga matematiken. Inte på en fusktextur eller någon annans demo, utan på substitutionssystemet från forskningsartikeln, validerat till maskinprecision.
• Det ska vara en förrenderad film, inte realtidsgrafik. Ljuset ska simuleras fysikaliskt och skärpedjupet ska komma från en simulerad lins. Målet var att ge filmen samma lugn som ett makrofoto i studio, och helt undvika den plastiga ytan i webbens realtidsgrafik.
• Inga färdiga komponenter. Ingen spelmotor, ingen tredjepartsrenderare, inget köpt material. Allt som syns i bild ska komma från kod i projektets eget repo.

En sak till: det var fredag, och sajten skulle ha sin film.

Nästa steg förvandlade den validerade matematiken till en 3D-värld. Varje plattas kontur krymps med 0,03 enheter. Det skapar smala spår mellan plattorna där ljuset senare kan fastna. Konturen trianguleras med en metod som klarar hattens inåtbuktande form, och extruderas därefter till ett prisma.

Plattornas höjder blev dygnets bästa påminnelse om att enkelt slår avancerat. Terrängen bygger på fraktalt brus i fyra oktaver med en våglängd på 42 enheter. Höjderna avrundas till 50 fasta terrassnivåer, och plötsligt ser landskapet ut som skulpterade sedimentlager i stället för formlösa kullar. De första försöken formade bruset med golvnivåer, havsnivåer och cosinusfunktioner, men alla resulterade i att något höjdband plattades ut onaturligt. Felen syntes direkt i renderarens preview-läge och ströks på minuter. Den slutliga lösningen krävde bara en enda rad:

# Ren linjär mappning utan formkurva. Golv, havsnivåer och cosinus
# plattar alla ut något höjdband. Linjärt bibehåller lutningen.
h = TERRAIN_AMP * n          # n = fraktalbrus utsträckt till 1..99-percentilen
if TERRAIN_STEP > 0:
    h = round(h / TERRAIN_STEP) * TERRAIN_STEP

Ovanpå detta får varje platta en egen slumpad höjdjustering på högst 0,03 enheter, så att grannplattor aldrig ligger exakt kloss an mot varandra.

Scenen innehåller bara det kameran hinner se under sin flygning: en remsa på 131 gånger 261 enheter som skurits ut längs rutten. Det första försöket skar bara ut ruttens mittlinje. Det räckte inte, eftersom synfältet kränger ut upp till tolv enheter åt sidan i svängarna, vilket fick mönstrets yttre gräns att dyka upp i bild som svarta kilar. Det var exakt den buggen som den externa modellen GPT 5.6 Sol hittade under en kodgranskning på kvällen. Lösningen blev att utöka mönstret från fyra till fem substitutionsnivåer.

Efter beskärningen återstår 10 127 plattor. Varje platta får ett eget material där ljushet och ytjämnhet varieras slumpmässigt, vilket gör att fältet glittrar diskret i stället för att se ut som en enda gjuten plastskiva.

De orangea accenterna väljs ut med den flugna rutten som facit. Scenbyggaren har en exakt kopia av drönarens flygmodell (porterad rad för rad från C++ och verifierad mot originalet). Med rutten känd letar skriptet upp spegelvända hattar max sju enheter från markspåret, med närmast förtur, och med minst åtta enheters lucka mellan varje accent. Det blev 19 stycken i den färdiga filmen. Kameran flyger rakt över dem, i stället för att låta dem skymta i ögonvrån. Varje accent görs svagt självlysande och renderas i en separat ljusbuffert som i efterbehandlingen skapar det mjuka lavaliknande skenet.

Till slut packas allt i en binärfil på 15,3 MB som renderaren läser in i ett svep: 10 128 material och 374 701 trianglar, ingenting annat.

Kameran var det svåraste att få rätt, och den del som skrevs om flest gånger. Plandokumentet loggar hela resan: först en rak kameraåkning. Därefter en perfekt loopande cirkelbana. Sedan en kamera som följde en utstakad kurva. Alla förkastades samma timme som de kördes, av en enkel anledning: en kamera på räls känns alltid som en kamera på räls, hur mjuk rälsen än är.

Den slutliga kameran är i stället en simulerad FPV-drönare med en actionkamera fast monterad i 45 graders vinkel nedåt. Den styrs av en kedja där varje led påverkar nästa:

// FPV-modell. Autopiloten ber om en acceleration för att följa
// rutten. Drönaren måste först kränga och vrida nosen mot den
// riktningen, och först därefter kan motorkraften ändra farten.
// Rörelsemängden bär genom svängen: vrid först, tryck sedan.
V3 requiredThrust = guideAccel + vel * (1.0f / dragTau);
float targetYaw   = atan2(requiredThrust.x, requiredThrust.y);
yawV += (wrapPi(targetYaw - yawS) * wY * wY - 2*zY*wY*yawV) * dt;
V3 bodyF{sin(yawS), cos(yawS), 0};        // nosen, inte rutten
V3 desiredAccel = clampLen(bodyF * thrust - vel * (1/dragTau), accelMax);
accel += clampLen(desiredAccel - accel, jerkMax * dt);   // rycktak

Styrningen siktar på en punkt femton enheter längre fram längs en kurva, men kan bara föreslå en ändring. Drönaren måste först vrida nosen mot den riktning där kraften behövs, och det är bara motorns dragkraft i nosens riktning som kan justera farten. Resten hanteras av rörelsemängden.

Filmen ser ut som en riktig drönarfilm eftersom den drivs av samma fysik. I filmens skarpaste sväng pekar drönarens kropp 30,4 grader vid sidan av färdriktningen, medan farten hålls stadig på två enheter per sekund. Kameran blickar in i svängen hela 19,9 grader innan flygbanan faktiskt byter riktning. Det är just den förväntansfulla inblicken som separerar FPV från räls. Horisonten lutar som mest 10,6 grader, vilket styrs helt av sidoaccelerationen och inte av någon konstlad bildjustering i efterhand.

En detalj är avgörande för helheten: flygsimuleringen körs från scratch för varje bildruta. Det låter dyrt men tar bara några mikrosekunder per frame, småpotatis jämfört med sekunder av ljusberäkning. Fördelen är att kameran saknar dolda tillstånd, den har ingen förberäknad bana, och det är totalt omöjligt att hamna ur synk.

Runt 18-tiden insåg vi att CPU-renderaren skulle behöva ett dygn – tid vi inte hade. Lösningen blev en gemensam kärna. Koden kan kompileras rakt av som C++17, CUDA eller Metal Shading Language. Ljusberäkning, optik och material är skrivet en enda gång.

#if defined(__METAL_VERSION__)
  #define HD inline          // funktionskvalificerare
  #define DEV device         // adressrymd för GPU-minne
  #define THR thread         // trådlokal adressrymd för referenser
  typedef uint u32; typedef ulong u64;
  HD float xsqrt(float v) { return metal::sqrt(v); }
#else                        // vanlig C++ / CUDA
  #define HD __host__ __device__ inline
  #define DEV
  #define THR
  HD float xsqrt(float v) { return sqrtf(v); }
#endif

Priset vi betalade för portabiliteten var några makron för adressrymd och ett par matematikfunktioner. Resterande kod per plattform var obetydlig:

Backend	Fil	Rader	Finessen
CPU	main.cpp	44	En arbetskö som sprider ut bildens rader över 16 kärnor.
CUDA	cuda_main.cu	90	Klyver arbetet i korta pass så att Windows inte tror att GPU:n har hängt sig.
Metal	metal_main.mm	136	GPU-kärnan kompileras blixtsnabbt direkt vid uppstart.

Vi jämförde maskinerna och fann dem visuellt identiska. Metal renderade en bildruta på cirka 6,5 sekunder, mot CPU:ns 38,6. Med de marginalerna gick det bra att starta rendertåget till kvällen.

Sista commiten rullades in 23:32. Renderskriptet drog igång Metal, och datorn fick tugga sig igenom 663 miljarder ljusvägar under natten: 2 220 bildrutor i 1080×1080 med 256 ljusvägar per pixel och max fem studsar vardera.

Renderingstiderna talar för sig själva. De blixtsnabba rutorna ser ner mot marken. De tunga partierna är s-svängen, där bergen drar sig tätt inpå linsen och fyller utsikterna med massiv oskärpa: strålarna sprids i en enorm kon och fler ljusstudsar får leva vidare till slutet. Snittet hamnade på 6,49 sekunder och laptopen blev klar fyra timmar senare. 03:41 låg startbilden på disken.

Art direction gjordes däremot 500 gånger snabbare. All regi baserades på ett preview-läge som växlade över till en knivskarp pinhole-kamera, en endaste ljusväg per pixel, och ingen tyngre skuggning. Det var i det bruset alla rutter sattes.

Nedan är bildrutor i hög upplösning, tagna från repot med exakt samma renderare och scen som filmen.

Att hinna formulera matematiken, C++-optiken och FPV-fysiken på ett enda dygn berodde på tre saker.

Snabba beslut. All art direction sattes på nolltid utifrån snabba preview-renderingar. Ingenting revs upp. Terrängen illustrerar det bäst: sex avancerade kurvor prövades och plattades ut, den linjära lösningen segrade. Snabba veton slår långsam konsensus.

Ett agentiskt arbetssätt. Vi skrev inte en rad kod. Anthropic Fable 5 i Claude Code gjorde all tunglyftning, från arkitekturen i path tracern till navigeringen av C++-minne och FPV-svängar. Plandokumentet agerade single source of truth för människa och agenter. Att låta en AI granska en annan är standard hos oss, och i det här fallet utfördes granskningarna av OpenAI:s GPT 5.6 Sol, som hittade och rättade flera logiska fällor innan vi hann lida av dem.

Stenhård determinism. Allt styrs av konfiguration i ren text, seedad logik och cachar länkade till innehållets identitet. Varken kameran eller renderaren beror på historiken. Just därför vågade vi bygga om grundläggande logik fyra gånger om, trygga i att allt var deterministiskt reproducerbart.

Hela projektet stannade på 373 rader Python, 551 rader scenlogik och 1 305 rader C++. TokenTek fick sin bakgrundsfilm. Att den råkade vara ett validerat matematiskt bevis kom på köpet.

Det är exakt så vi utvecklar för våra kunder, fast då brukar det handla om dataflöden i stället för simulerade drönare över aperiodiska plattor. Målen är tydliga, besluten går snabbt, och AI-agenter skriver varenda rad.

Substitutionsreglerna är porterade från Craig S. Kaplans hatviz (BSD-3-Clause). Plattan kommer ur artikeln "An aperiodic monotile" av Smith, Myers, Kaplan och Goodman-Strauss, 2023. Allt annat i projektet, generatorn, renderaren, kameran och pipelinen, skrevs från grunden den 10 juli 2026.