The neon city, live
Three.js, live: the neon city to ride, fly and walk through in a browser. 240 lots worked out as arrays from a seed -- another seed is another city -- built in the page by X_eTaL compiled to WebAssembly and drawn by a player written with Three.js: lit towers, neon, screens showing slides and videos, puddles that mirror it all, cars and fliers. The same arrays and the same calls as the ray-traced film (blender's demos/NeonCity.xtl, Cycles.xtl). From the command line this writes a directory to serve, work/city: the page, the player, Three.js and the calls.
audio facade docs
Audio files for X_eTaL: decode Ogg Vorbis, MP3 and WAV, play them on the sound device, and read what is playing as arrays -- the window of samples under the playhead, for analysis and pictures (the visualizer).
audio / scope source and docs
A live oscilloscope: the synthesizer's music (Instruments.xtl) plays while a window draws the samples under the playhead -- the left channel above, the right below -- each frame, triggered on the left channel's rising zero crossing so a steady chord stands still.
just demo audio scope
audio / spectrum source and docs
The music visualizer: an Ogg Vorbis (or MP3, WAV) file plays while X_eTaL turns what is playing into a spectrum and the spectrum into 16 spokes in a 3D window -- Rust decodes, plays and draws; the analysis and the picture's geometry are X_eTaL arrays.
just demo audio spectrum
audio / synth source and docs
A synthesizer made of arrays: X_eTaL computes every sample of a little piece -- notes from equal temperament, harmonics, envelopes, chords, stereo (the instruments are in Instruments.xtl, beside this file) -- and the audio extension plays them as they are made.
just demo audio synth
blender facade docs
Blender 3D in batch, driven from X_eTaL. An X_eTaL program writes the Python -- a launcher that runs Blender in the background, and the bpy script Blender runs inside -- runs the launcher, and reads back what it made: rendered pictures and videos, 3D files. The chain is X_eTaL, this extension, python3, Blender, Python inside Blender.
The neon city, ray-traced: the whole flight, rough source and docs the same city, live: fly and walk through it
Blender, ray-traced: the city's whole flight, rough and quick -- 640 by 360, 24 frames a second, 12 samples a pixel -- to judge the camera's move, the traffic and the screens before the film is rendered. The frames go to work/city/preview/frames (a frame already there is not rendered again), the video to work/city/preview.
just ext blender city-preview
The neon city, ray-traced: four stills source and docs the same city, live: fly and walk through it
Blender, ray-traced: a city at night after rain, flown through. The city is arrays (NeonCity.xtl): 240 lots, each tower's height, footprint and skin from a hash of its number; screens, neon, lamps, steam, bridges, cars and fliers, all rows of tables that Cycles.xtl writes into Blender's Python. Here: four stills along the camera's flight, 1280 by 720, ray-traced by Cycles (the graphics card when there is one), written to work/city/out.
just demo blender city
blender / cosy source and docs CoSy reva-fork
Blender, 6: the CoSy logo in 3D. C, o, S and y are round tubes, toothpaste style, melted together where they touch, glossy magenta on yellow, turned once round; the video loops. Each letter is its center line, an array of points traced from the logo and placed in meters by X_eTaL (CosyLogo.xtl); Blender gives each line a round tube and round ends, fuses them into one mesh and renders it with Cycles.
just demo blender cosy
blender / cubes source and docs
Blender, 2: how big is a thousand? One cube, a hundred, a thousand, side by side -- xkcd style -- rendered by Blender from a script X_eTaL writes: every cube's corners and faces are X_eTaL arrays, written into the script as numbers (Bpy.xtl, Sizes.xtl). The camera goes once round them; the video loops. Blender also writes the scene as files to open elsewhere: sizes.glb (glTF), sizes.obj and sizes.blend.
just demo blender cubes
blender / game-assets source and docs the pieces in 3D (published)
Blender, 4: game assets. X_eTaL makes the twelve tower defense pieces for X_eTaL-games and everything published with them: it writes the Python -- the launcher, and the bpy script describing each piece (Td.xtl) -- Python runs Blender, Blender runs the script: each piece is written as NAME.glb with its clips, rendered alone as NAME.png and as two sheets of frames (NAME-turn.png, NAME-map.png), shown close, one after another, turning and playing each clip, for one video, and all twelve lined up for another. Then X_eTaL hashes every file (the digest extension) into manifest.toml and writes the page that shows them, index.html, all in work/td/site. just ext blender publish-td copies that into the site, at blender/td/.
just demo blender game-assets
X_eTaL GPU: build process source and docs compiler artifacts
X_eTaL source to resolved Core, typed XIR and fused OpenCL kernels. Compare the pinned M1 Max and RTX 5060 Ti schedule files, including a matrix example. Compiler evidence only; no device timing claims.
just ext blender gpu-build
X_eTaL GPU: execution source and docs execution evidence
Execute the emitted OpenCL plan, check results, then explain its trace.
just ext blender gpu-run-data && just ext blender gpu-run
blender / hello source and docs
Blender, 1: X_eTaL runs Blender. The program writes two Python files -- the launcher, which runs Blender in the background (with its factory settings, so the run never depends on yours), and the script Blender runs inside, which writes a report -- then runs the launcher with python3 and reads the report back. The chain: X_eTaL, the extension, python3, Blender, Python inside Blender.
just demo blender hello
HEX1000-UART: build process source and docs
Blender, 11: HEX1000-UART from source to a configured Tang Nano 9K. Run just ext blender hex-build with the OSS CAD Suite on PATH: synthesize, place, route, pack, then render this video and Short. The build evidence stays in work/hexbuild/evidence.json.
just ext blender hex-build
HEX1000-keys-leds: build process source and docs
HEX1000-keys-leds from source to a configured Tang Nano 1K. The full physical calculator: actual cell placement, routed wire footprints, both clock results, and schematic configuration.
just ext blender hex-keys-leds-build
HEX1000-keys-leds: execution source and docs
HEX1000-keys-leds computing C0DE+BEEF= through physical key contacts and MAX7219 serial output: the complete pinned Nano 1K simulation, checked against the Hex1000 and Front models at every active clock.
just ext blender hex-keys-leds-run
blender / hex-pc source and docs
Blender, 9: HEX1000's program counter, an explainer made with the kit. The 64 addresses of a ROM page as cells in reading order; the program counter visits them in its shift register's order -- 0 1 3 7 15 31 63 62 ..., never +1 -- each cell lit as it is reached, colored by when, the path drawn behind. The order is X_eTaL-fpga's Hex1000 library (pinned at FPGA_COMMIT); the first hops in slow motion, the rest a time-lapse, after a title card, with captions. Made twice -- a YouTube video (1920 by 1080) and a Short (1080 by 1920) -- with a cue sheet and subtitles (.srt) to record narration against (PcWalk.xtl).
just demo blender hex-pc
HEX1000-UART: execution source and docs
Blender, 10: HEX1000-UART computing C0DE+BEEF=, from a simulation of its board. scripts/hex1000-sim.sh runs X_eTaL-fpga's board Verilog (at FPGA_COMMIT) under iverilog, the text sent over its serial line, into a waveform (VCD); scripts/hex1000-browser.py types the same text at the live browser calculator in headless Chrome. This program reads the waveform (Vcd.xtl), checks it -- the line carries the text, the board receives it, Hex1000.xtl replaying the clocks agrees with the circuit's registers at every one, the display ends as the evaluator's (hx:c_alc) and the browser's -- and only then writes the video (HexRun.xtl): the bits arriving and the key matrix in slow motion, the typing as a time-lapse, one addition in slow motion, the display, the browser's screen beside it. A YouTube video and a Short, with a cue sheet and subtitles.
just ext blender hex-run
blender / matmul-fly source and docs literate document
Blender, 7: a 512 x 512 matrix product as a 3D construct, a fly-through, arrays to video. A on the left wall, B on the ceiling, C on the front wall, every item a cell colored by its value; the camera starts far out (the whole cube: 134 million multiply-adds), flies to one work-group's 16 by 16 tile, then one work-item -- a row of A times a column of B, 512 products added into one item of C -- and back out while C fills in, a work-group at a time. The product is X_eTaL-gpu's Accel ac:m_atmul; every place, color and time is an array worked out in X_eTaL (demos/MatmulFly.xtl); Video.xtl writes them into the script Blender runs. Explained in docs/literate/matmul.org.
just demo blender matmul-fly
blender / matmul-steps source and docs literate document
Blender, 6: a matrix product a step at a time, arrays to video. C = A x B for X_eTaL-gpu's matmul demo ([3 4] x [4 2], by its Accel library): A on the left wall, B on the ceiling, C on the back wall. Item by item, a row of A and a column of B light up, their four products appear in the cube between them and fly into C's item, which shows their sum; then all six at once, as a GPU works them out, one work-item each. Every place, color and time is an array worked out in X_eTaL (demos/Matmul.xtl); Video.xtl writes them into the script Blender runs. Explained step by step in docs/literate/matmul.org.
just demo blender matmul-steps
blender / relu-softmax source and docs literate document
Blender, 5: ReLU and softmax, arrays to video. A tiny network's layers, run by X_eTaL-gpu's Accel library (the functions its GPU runs), shown as bars: ReLU turns z1's negatives to 0, softmax turns each row of z2 into two shares of 1, a step at a time. Every bar's place, size, color and timing, every label and the camera's path are arrays worked out in X_eTaL (demos/ReluSoftmax.xtl); Video.xtl writes them into the script Blender runs. Explained step by step in docs/literate/relu-softmax.org.
just demo blender relu-softmax
blender / td-models source and docs the pieces in 3D (published)
Blender, 3: game pieces. The twelve tower defense pieces X_eTaL-games asked for -- arrow, cannon and frost towers at three levels, runner, brute and shield creeps -- described in X_eTaL (Td.xtl: boxes, cylinders, cones, spheres, rings, crystals and turned profiles, the parts that move in groups, the clips keyed from each part's rest), written as one bpy script, and exported by Blender as one glTF file a piece with its named clips: idle, fire, walk, hit. Each file's clips are read back from it.
just demo blender td-models
canvas facade docs
A native window showing X_eTaL arrays as pixels, with keys, clicks and frame ticks back -- the first extension served by the UI host (crates/xetal-ext-ui), and the base of the media saga's visualizer.
canvas / life source and docs
Conway's Life in a native window: the board is an X_eTaL array, each generation one array expression, drawn by Rust with every frame.
just demo canvas life
clock facade docs
Wall-clock and monotonic time: timestamps for programs (as Unix seconds or ISO 8601 text), and timing for benchmarks -- including the cost of the bridge itself. X_eTaL itself now has the time of day ([]TS) and a delay ([]D_L), but no monotonic clock yet (docs/xetal-asks.md in the repository, E4).
clock / bridge-cost source and docs
What the text bridge costs (docs/bridge.md): calls per second, and Floats per second carried out and back (it uses hello too).
just demo clock bridge-cost
digest facade docs
SHA-256 and CRC-32 for X_eTaL, of text and of files: to check that content is what it should be -- a downloaded feed against the digest recorded when it was saved, a file against a checksum published beside it.
No demo yet.
hello facade docs
The smallest X_eTaL native extension. It exists to prove the boundary: each function exercises one thing a real extension needs.
hello / tour source and docs
A tour of the hello extension: X_eTaL arrays handed to Rust and back.
just demo hello tour
http facade docs
<p align="center"> <img src="../videos/quakes.webp" alt="The earthquake report at the command line" width="640"> </p>
http / quakes-live source and docs
Earthquakes of the past week, live: the USGS feed of magnitude 2.5 and up, fetched now (the network: run it only when you mean to), its SHA-256 shown, then the same report as quakes.xtl.
(no recording yet)
just demo http quakes-live
http / quakes source and docs
Earthquakes of a week: the USGS feed of magnitude 2.5 and up, saved 2026-10-06 (demos/data/PROVENANCE.txt), checked against its SHA-256, into SQLite; SQL selects and groups, X_eTaL computes (the magnitude-frequency law), pictures show it.
just demo http quakes
image facade docs
<p align="center"> <img src="../videos/photo-lab.webp" alt="The photo lab: filters, the SVD at three ranks, sepia" width="640"> </p>
image / photo-lab source and docs
The photo lab: a photo is an array. Buzz Aldrin on the Moon (Apollo 11, NASA, public domain: demos/data/PROVENANCE.txt) read as numbers; filters and edges by rotating the array (the Life idiom), a color toning by an inner product, and the SVD compressing it at several ranks -- the native code reads, writes and decomposes, X_eTaL does the rest. Pictures go to work/photo-lab/.
just demo image photo-lab
linalg facade docs
Numerical linear algebra for X_eTaL, through nalgebra: solving systems, inverses, determinants, least squares, symmetric eigenvalues and the singular value decomposition -- the algorithms an array language should call, not reinvent. Matrices are Float arrays, rows by columns.
No demo yet.
scene facade docs
Retained 3D scenes in a native window: an X_eTaL program puts objects under ids it chooses (a polyline, segments, dots, filled quads) and patches them later; Rust draws them in perspective from an orbit camera, which the mouse turns -- quads shaded and depth-tested, lines over them. The base of the visualizer and of the voxel demos.
scene / cube source and docs
A wireframe cube turning in a native 3D window: its corners and edges are X_eTaL arrays; Rust draws them.
just demo scene cube
scene / voxels-chunk source and docs
Voxels, 1: a chunk is an array. 16 by 16 by 16 block numbers built from a height field in a few array expressions -- grass, dirt, stone, water below a level, sand at its shore, one tree -- then counted, cut and seen from above. (docs/voxels.md; the next demos draw it.)
just demo scene voxels-chunk
scene / voxels-dig source and docs
Voxels, 10: digging and building in the endless world. A crosshair marks where you look; the block under it, within 5 blocks, is found by marching 100 points along the view ray (en:p_ick). Click it to dig it out; right-click to place a block of the kind chosen on the hotbar against it. Each change is an edit the world remembers (x y z and the block), and every column is made with its edits -- the edited one made again at once (and its neighbor, when the block is on their border), so walk away and come back and the hole is still there.
just demo scene voxels-dig
scene / voxels-endless source and docs
Voxels, 6: an endless world. Walk in any direction and it never ends: the land comes from value noise hashed from the coordinates (vx:h_eightsAt), so any column of 16 by 16 blocks can be made by itself and fits its neighbors; columns are made around the player as it walks -- the nearest missing one each frame -- and dropped behind it; fog hides the edge of what is made, and a curved horizon (scene lowers the world by d^2 / 2R) makes it look like a small planet. Collision asks the columns themselves. The world and the player are the library Endless.xtl, shared with voxels-fly: each column is made over three frames, so no frame waits long.
just demo scene voxels-endless
scene / voxels-faces source and docs
Voxels, 2: which faces to draw. A face shows where a solid block's neighbor is not solid: six rotations of the solid mask, each compared with the mask itself (the idiom of Life), give every exposed face of the chunk at once; the faces become a list, one row each: x y z direction block. Checked on shapes with known answers, then the chunk's faces drawn as outlines in a 3D window, turning.
just demo scene voxels-faces
scene / voxels-fly source and docs
Voxels, 7: flying. The endless world of voxels-endless, now from the air: F switches between walking and flying. Flying moves level whatever you look at -- W forward, S back, A and D sideways -- Space rises and Shift sinks, with no gravity, the blocks still stopping you; so you can look down at the land as you cross it. F again drops you back to walking wherever you are. The columns are made ahead, one a frame, and dropped behind, under fog and a curved horizon.
just demo scene voxels-fly
scene / voxels-game source and docs
Voxels, 15: Gem Hunt. Ten gems are buried around the start, a few blocks under the surface; dig them out in three minutes. The first lies four blocks straight down from where you start; the others are scattered within a dozen blocks, deeper. Gems glow a little (12 where a lamp is 15), so a tunnel near one is lit -- and the corner of the screen says how far the nearest gem you have not found is. Everything from the voxel demos works: dig, place, lamps, water, night. G gives up and shows the score. The game is X_eTaL: the gems are edits, a find is a dig whose cell is a gem's, the clock is the frames (60 a second), the labels are scene's.
just demo scene voxels-game
scene / voxels-light source and docs
Voxels, 14: light. The endless world, lit: a face open to the sky is in full sunlight; under an overhang, beneath a tree's crown or down a tunnel the light fades, a step a block, as it spreads from the open air. A lamp (the hotbar's eighth block) glows: its light spreads the same way through the air around it. N turns day to night and back -- the sunlight and the sky go, the lamps stay -- by one number in scene, so nothing is worked out again. Each column's light is worked out as it is made (vx:c_olumnLight: sunlight by a scan down each column, then rounds of spreading), and again when an edit makes it again: dig a tunnel's roof open and the sun comes in.
just demo scene voxels-light
scene / voxels-rubik-buttons source and docs
Voxels, 12: the Rubik's cube with buttons. Six buttons under the cube turn its top, right and front layers a quarter turn either way -- U and U' the top, R and R' the right, F and F' the front (a letter alone clockwise as you look at that face, with ' counterclockwise), which between them reach every position of the cube. Each press is animated, a quarter turn in 8 frames; presses made while a turn is under way wait their turn, so the cube answers at once and never drops one. The turns made are shown above the cube.
just demo scene voxels-rubik-buttons
scene / voxels-rubik-solve source and docs

Voxels, 13: the Rubik's cube solved. Scramble it, or turn it with the six buttons, then Solve: the cube's turns so far are handed to the Eigencube library (X_eTaL-libraries, at LIBRARIES_COMMIT), which holds the cube as 26 rotation matrices and solves it by search, stage by stage -- the first layer by plain search over the twelve turns, the middle and last layers over known move sequences (slot inserts, an edge flip, Sune, a corner cycle), which is what makes it fast enough (2 to 3 seconds; a hundred and some moves). Then Step through the solution a turn at a time, Back to undo one, or Play it through, every turn animated on the voxel cube. The two models are checked to agree (tests/rubik-eigencube.xtl).
just demo scene voxels-rubik-solve
scene / voxels-rubik-turn source and docs
Voxels, 9: a quarter turn, seen. One layer of the Rubik's cube -- 9 cubies, a "plane" -- turns a quarter revolution while the rest stays still: its cubies' bodies and stickers rotated a little more each frame (a rotation matrix, one inner product), then the cube's colors permuted once it is done. A scramble: twelve quarter turns, each on a different axis from the one before (the faces in the order U R F D L B, twice), the directions + + - - + - and then - + + + - +; a pause; then the same turns undone in reverse, back to solved.
just demo scene voxels-rubik-turn
scene / voxels-rubik source and docs
Voxels, 8: a Rubik's cube. 26 dark cubies with their colored stickers, drawn as voxels; the cube itself is arrays (Rubik.xtl): its 54 stickers, each where it is and which way it faces, and each of the twelve quarter turns a permutation of them, computed from the cube's geometry. This demo checks the turns -- each a permutation, four of one solved, a turn and its undoing solved, R U R' U' of order 6, R U of order 105, and U and R turning the right way -- and shows the solved cube, turning slowly; keys turn its faces.
just demo scene voxels-rubik
scene / voxels-solid source and docs
Voxels, 3: the chunk drawn solid. The same faces as voxels-faces, each now a filled quad -- its four corners from a 6 by 4 table by direction -- one object per kind of block; scene shades each by how it faces the light and hides the farther ones behind the nearer (a depth buffer), with a little fog. All the array work is X_eTaL's; Rust only draws.
just demo scene voxels-solid
scene / voxels-walk source and docs
Voxels, 5: walking. The island of voxels-world, seen from inside it. The player is nine numbers -- x y z (feet), vx vy vz, yaw, pitch, on the ground -- and every frame X_eTaL reads the keys and the mouse, turns, falls, jumps, and moves one axis at a time against the solid blocks the player's box would overlap, stopping at the face of the block it hits (a swept box per axis, as the APL game collides); then it sets scene's first-person camera. It also tests the 32 chunks against the planes of the view, as the APL game culls (key c).
just demo scene voxels-walk
scene / voxels-water source and docs literate document
Voxels, 11: water that flows. A stepped hill stands by the start with a lake on its top terrace, held in by a rim of grass. Dig into the rim and the lake spills out and runs down the steps like a waterfall; dig beside the sea and the hole fills. Water flows as a cellular automaton on the cells it has just reached (Endless.xtl): each tick a cell falls into the air below it, or, standing on something solid, spreads one level lower into the air at its sides, 7 levels from a source; the lake and the sea are sources that never empty. The cells it reaches are edits like any dug or placed block, so the water stays where it ran. Water is drawn translucent: the lake's floor and the seabed show through.
just demo scene voxels-water
scene / voxels-world source and docs
Voxels, 4: a world of chunks. An island 64 by 32 by 64 -- 32 chunks of 16 cubed -- from value noise made by linear algebra (random heights on grids every 16, 8 and 4 blocks, each interpolated as M G M'), shaped by the chunk's rules over the whole world at once, with trees planted by folding one tree over a list of places. Its faces are found over the whole array (so faces between chunks hide each other), then sent to scene chunk by chunk, each chunk's kinds of block under their own ids -- the ids a later demo patches when a block changes.
just demo scene voxels-world
sqlite facade docs
SQLite databases for X_eTaL: run statements, and bring query results back as X_eTaL arrays -- numbers as a matrix to compute on, text as a Char matrix -- through rusqlite with SQLite compiled in.
sqlite / notebook source and docs
The data notebook: a CSV in SQLite, SQL to select and group, X_eTaL arrays to compute, pictures to see it. Atmospheric CO2 at Mauna Loa, 1959-2025 (NOAA GML and Scripps; demos/data/PROVENANCE.txt).
just demo sqlite notebook
three facade docs
Interactive 3D in a browser. An X_eTaL program writes a scene as the calls of a player -- the same text the blender extension's Cycles.xtl writes for a ray-traced film -- and here a player written with Three.js draws those calls in real time: ride the camera's flight, fly, or walk. The first scene is the neon city: 240 lots worked out as arrays from a seed, so another seed is another city, built in the page by X_eTaL compiled to WebAssembly.
The neon city, live source and docs fly and walk through it, live the same city, ray-traced by Blender
Three.js, live: the neon city to ride, fly and walk through in a browser. 240 lots worked out as arrays from a seed -- another seed is another city -- built in the page by X_eTaL compiled to WebAssembly and drawn by a player written with Three.js: lit towers, neon, screens showing slides and videos, puddles that mirror it all, cars and fliers. The same arrays and the same calls as the ray-traced film (blender's demos/NeonCity.xtl, Cycles.xtl). From the command line this writes a directory to serve, work/city: the page, the player, Three.js and the calls.
just ext three city && just ext three serve city
web facade docs
<p align="center"> <img src="../videos/todomvc.webp" alt="TodoMVC served by an X_eTaL program" width="420"> <img src="../videos/life.webp" alt="Life computed in X_eTaL, one generation per request" width="320"> </p>
web / life source and docs
A live page: Conway's Life kept by an X_eTaL program and drawn as SVG, one generation per request. The program is the server's request loop.
just demo web life
web / todomvc source and docs
TodoMVC on the web: the todos live in SQLite, the X_eTaL program is the server -- it routes each request, keeps the filter, counts what is left, and writes the page; forms post and are redirected back.
just demo web todomvc