Simon Crowe

@simon-crowe.bsky.social

49 Followers 192 Following

Software Engineer -- Python / Platfom. Tinkering with Rust, Go, Electronic music. simoncrowe.blog https://fosstodon.org/@simoncrowe

ASCII-art diagram titled "One token by telegraph", showing how one transformer layer would be computed by a fictional civilisation. At the top, a skyline drawing depicts the Capital — a city of 1,000,000 core scribes — connected by roughly 300 km of telegraph wire (100 bits per second, signals at 0.7c) to the Towns, where 10,000,000 more scribes work. Below the skyline is a timeline for computing one layer (layer k of 120, processed strictly in order), with two parallel columns: the Capital (one million scribes, 10 km wide) and the Towns (ten million scribes, 300 km out). The timeline reads: Hour 0.0: the Capital begins self-attention. This happens in the core only, because every desk may need to read the whole token census. Half the city is on duty at any time, in two 12-hour shifts. It takes 9.4 hours of arithmetic plus 1.8 hours of keying messages across the city's own wires, finishing at hour 11.3. Hour 11.3: the Capital transmits the MLP inputs for layer k to the Towns — 327 kilobits, about 0.9 hours of keying. The 300 km of light-lag adds only 1.4 milliseconds. Hour 12.2: both sides compute the MLP feed-forward in step. The Towns' ten million desks each work on their own slice, no town consulting another; the Capital's on-duty half joins with its own share. This takes 0.9 hours. Hour 13.0: the Towns key the MLP outputs back to the Capital — another 327 kilobits, 0.9 hours. Hour 13.9: the Capital performs the residual add and normalisation and files the layer record (negligible time). The hidden state then passes to layer k+1, back to the top of the cycle, while the towns sit idle until the next dispatch keys in.
A screenshot of a full-page WebGL canvas on a web page served from my local machine. The canvas shows some sinuous red and purple organic forms twisted around each-other and receding into a dark blue background. To the top left of the canvas is a heads-up-display with some settings to control a reaction-diffusion simulation as well as several parameters controlling graphics.
error[E0609]: no field `positionition` on type `Vertex` --> wasm/src/meshing.rs:37:37 | 37 | let ib = self.push_vertex(b.positionition, b.normal, color); | ^^^^^^^^^^^^^ unknown field | = note: available fields are: `position`, `normal`
A 3d scene displayed on a webgl canvas: A number of blue blob-like volumes are arrayed against a dark background.
Some tiled terminal widows. The window on the right shows some computer graphics focused rust code the defintiion fo a function called ... The left-hand terminal shows the OpenCode agentic coding tool, displaying a message from CPT 5.2: That behavior is mostly “simulation is collapsing to a near-uniform state”, plus two visualization choices that make the end-stage look especially weird: - HUD V[0.000,0.000] was likely just rounding hiding that V had a tiny remaining range. - The viewer was using an adaptive isovalue iso = (vMin + vMax) * 0.5 (web/main.js:375 before), so as the scalar range collapses toward ~0 it keeps chasing it. That produces: - very “blocky” surfaces (iso near min/max, lots of near-degenerate crossings), - almost-zero gradients → unstable/flat normals, - and eventually no surface once the field becomes effectively constant. I made two concrete fixes to separate “rendering artifact” from “sim actually went uniform”: 1) Fixed isovalue + more informative HUD - Mesh generation now uses a constant iso = 0.5 (web/main.js:375 and web/main.js:447). - HUD now prints 6 decimals and dV (range) so you can see when it’s really flat vs just rounding (web/main.js:437). With this, if the sim truly decays toward V≈0 everywhere, the mesh will cleanly disappear (because nothing crosses iso=0.5). That’s expected, and it tells you the simulation reached the homogeneous equilibrium. 2) Stop “normal flipping” from degenerate gradients - Gradients are now stored unnormalized (raw central differences), and the shader continues to normalize per-fragment (wasm/src/meshing.rs:62, wasm/src/meshing.rs:76). This avoids the previous behavior where near-zero gradients turned into an arbitrary fallback normal, which can look like normals “flip” or go flat/blocky as the field gets smooth. Also - Perlin seeding now uses v_amp = 1.0 so iso=0.5 can actually produce a surface (web/main.js:335).