What's new
What has changed in Field·4 and on this site, newest first. Each entry covers a few days of work: the features that arrived, linked to the page that describes them, and the pages that are new or were rewritten. Small fixes and wording changes are left out; the Changelog panel on Field's Welcome screen lists every commit in your own checkout.
November 2026
Screenshots at the size Field draws them, and a generator graded by Datalog
Captures on every page now display at 1.5× the size Field drew them, so text in a screenshot reads at about the size of the text around it. A new example page hands a flow-matching generator's points to a Datalog program, which checks whether they kept the target cloud's shape. A Generator, Graded by Datalog.
Evolution against random sampling, on the same budget
- Braitenberg vehicles: a new section evolves vehicle brains on a larger genome and compares evolution with random sampling at the same budget. A larger genome.
- ALife search: the same equal-budget comparison now runs on three genomes. Does search beat random?.
- The chain pages were revised from a first-time reader's notes, and the docs site's background is a little lighter.
Field inside VR
- Field inside VR: edit Kotlin, run boxes and move around the canvas with the headset on, in a browser panel inside Field's OpenXR scene. Controllers point, scroll and resize it, and a real keyboard and mouse work on Quest 3 with WiVRn and on Vision Pro through ALVR. Field inside VR.
- Keyframe sweeps can render chosen blends, including blends past the saved keys. Blending past the saved keys.
- The path tracing page and dozens of others gained captures that were missing or weak, and SolidCraft moved to v0.30.
Typeset math across the docs, and moving lights for Braitenberg vehicles
- Math is now typeset on 37 pages.
- Braitenberg vehicles gain moving lights, a price on speed, and evolved wirings. Moving lights, Searching for a wiring.
- Snapping moved into Moving around the canvas.
- The documentation panel inside Field has back and forward, and many pages gained real captures of sound, video and live windows.
A picture of the renderer window in a box
snapshotWindowputs a picture of the renderer window in a box's output.- FieldML
framesbodies can wait on Kotlinsuspendcalls withhostAwait. Waiting inside a frames body. - Graphics lessons: every lesson in the bundled graphics curriculum now has its picture, and the glTF lessons load the toy car. Field 4 graphics.
error(...)on a box's output is nowdisplayError(...).
October 2026
Braitenberg vehicles with memory
- Braitenberg vehicles: a new page builds vehicles from one neuron up, through four wirings, boredom, learning and circling at a set distance. Braitenberg vehicles.
- Offline viewer: open a document zip in the browser and import it whole into Field.
- Graphics: sections that were code only now have captures, including films of the native renderer window. Field 4 graphics.
- The Petri nets page lets you hear its two-place loop.
Presets, morphing and MIDI learn for any control group
- Controls: a control group gets presets you can morph between, recording into keyframes and
MIDI learn. Presets are keyframer keys, and a keyframed control is declared as
var size by keys.slider(...). Presets and morphing, MIDI learn. - FieldML calls Kotlin
suspendmethods withhostLaunch. Calling a suspend method. - Templates:
cmd+tlists personal templates too, in one precedence order. Insert a template. - The Patchy, presentation, layers and demo document pages were revised after a fresh read.
The starting pages, revised for a first-time reader
The front page, installation, first steps, the Survival Guide, the Tour and its stops were revised from a first-time reader's notes. A Tour of the Interface now shows every panel with a real document doing its job, and the keyframer and keyframe editor pages lead with the task. Box code across the site is now formatted consistently, and plane-grid figures use a flat card.
A tour of the interface, and one box's history
- A Tour of the Interface: a new page on the shortcuts, editor, palettes, search, bookmarks, layers, drawing layer, Macro Recorder, history and publishing. A Tour of the Interface.
- This Box in the history panel lists one box's code across every version and restores just that box. One box, edit by edit.
- Field's panels share one close button, title and look, and Escape closes them consistently.
- Code fences highlight whole, and comment and blank lines carry no line number, in the docs and the editor.
Templates, generative mocap and a stereo composite
- Templates: save boxes as a template, insert one with
cmd+t, and see where a copy came from. Templates. - Generative Mocap: open motion recordings, run a live simulated body, write a movement score and give it an intention or a route. Generative Mocap.
- Stereo RTT composite: a desktop-first stereo starting point, with or without a headset. Stereo RTT composite.
- Every value figure on Visualizers is now captured from a real box, and the reference gains an animation page.
Smoother XY pads and sliders, and a tour of your own document
- Controls: XY pads take arrow keys, reset and fine drags, a focused slider follows the wheel, and a drag survives the box re-rendering. Handling an XY pad.
- Interactive guides can tour your own document. A tour of your own document.
- Browse a glTF scene in the inspector. Browsing a glTF scene.
- Output frames arrive in order and display panels are never dropped, re-runs start faster, and the reference documents many more members.
Euler spirals as true clothoids, and an AI4 that reads code more closely
- Euler spirals are fitted as true G1 clothoids. Euler spiral in 3D.
- AI4 shows its model's progress live, finds lines and near-matches in attachments, can ask what a name means at a place in a box's code, and searches the docs literally. Local requests may run for 45 minutes. AI4's built-in tools.
- Classes in a box can call
printlnanddisplay. - Each document in the starting-point gallery has a web publication that opens beside its entry.
Euclid's later books, and web publications with outputs
- Euclid's Elements now spans Books I to VI, with I.47, filled areas and every way a construction can come out. Every solution.
- Publish for the web: package a document as a static site with every box's captured output, including interactive Three.js views. Publishing a document.
- Drawing layer: text defaults to Iosevka with plain styling, and the drawing has its own row in the docked layers panel.
Euclid's Elements, drawn like Byrne's plates
- Euclid's Elements: write a proposition as a compass-and-straightedge construction from 2-D points, lines, circles and arcs, and see it drawn in the style of Byrne's coloured edition, starting with Book I. Euclid's Elements.
- Field from your phone: the Pad tab scrubs a number in the code open on the desktop, and tabs can be opened straight from a link. Field from your phone.
- Saved documents can be offered as starting points as they are, and the three StackSL conversations are now starting points.
More reference overviews, and fewer surprises when editing on disk
Many more files in the reference gained an overview, and others were
rewritten in plainer language. Editing connections in metadata.edn now rewires the open boxes,
and a newer inline copy of a property wins over its file
(The document on disk). Attaching to a running Field no longer replays old
output over a slider you just dragged, and editing a launched Kotlin box no longer leaks a compiler
each time.
Spreadsheets in a box, and interrupting a box that never returns
- Spreadsheets: a sheet in a box whose formulas are Kotlin, with units, vectors and drawings in cells, values read from other boxes, and cells solved for from constraints. Spreadsheets, Solving for cells.
- Runaway boxes: box code that never returns is interrupted after 30 seconds, or at once with Interrupt Running Box. Code that never returns.
- A pen that sees: a learned pen that senses the ink around its tip, so it can follow a line, stop at one or hatch around a drawing. A pen that sees.
- Browse the renderer in the inspector: its passes, resources and shader stages. Browsing the renderer.
- The Tour's screenshots were retaken.
A learned pen that continues your lines
- A learned pen: a handwriting network that carries on from the end of any
FLine, as one continuation, many alternatives, or a pen that keeps writing live. A learned pen. - Teaching a pen: train pens on corpora of ordered drawings and see what each learned. Teaching a pen.
- AI4 as a coding agent: AI4 can work on Field's own repository in headless jobs, alongside claude and codex. Working on Field's own repository.
- The Tour introduces live presentations.
AI4's built-in tools, documented
- AI4's tools: a new page shows every built-in tool with real calls: making and running boxes, reading output, tracing where a value comes from, changing a box. AI4 can also stop and ask you a question. AI4's built-in tools.
- A Terminal in a Box has its own page, with
topanddfcaptures. A Terminal in a Box. - Presentations gain CSS themes, element fades, builds that keep earlier content, repeatable cues and search. Themes and simple builds.
- A stop that has not taken effect yet pulses the box's status marker, and how values travel down connections is now part of Running code.
Javascript boxes in a browser tab
- Javascript in a browser tab: sketch in a browser from a Javascript box, with errors on their lines, drawing and animation, controls and output channels. Javascript in a browser tab. Kotlin compiled for the browser gets the same printing, errors and controls. Kotlin in the head.
- Lua: the page was checked against the runtime, recaptured, and now covers the API it had left out. Lua.
- FLine examples: weak examples were redrawn, and interpolator morphs show as a filmstrip. FLine.
The demo document, and a Kits library on the welcome page
- The demo document: one canvas that shows most of what Field does, and the film on the home page is a tour of it. The Demo Document.
- Kits are listed in a compact library on the welcome page and can be restarted. Add a self-contained kit in Welcome.
- AI4 with a local model fits its context to the model, and its semantic and tutorial code search work. Local AI.
- Macros replay a box's current code, not a recorded copy, and Ceres solvers no longer crash on segments that share a point.
A renewed offline viewer, and math in the AI chat
- Offline viewer: a document opened in the browser without Field now shows box notes as
Markdown, the drawing layer, zoom, bookmarks and layers, and the site has a gallery of every
document it ships. The
offline_viewer_demostarting point is a small example. - AI4 typesets math in its chat.
- Presentations: slides can be authored in Field with a hierarchical outline, and Kotlin guide-based presentations are the default. Presenting with Field.
- Pack Boxes tidies the canvas and can make room for open outputs, and a box's resize handle stays the same size on screen at any zoom.
Presenting with Field, local AI models, and layers
- Presenting with Field: build a talk from slides written in Kotlin and HTML, with themes, builds and working material brought on screen. Presenting with Field.
- Local AI: connect Field's AI to a model server on your own machine, such as Qwen through llama.cpp. Local AI.
- Layers: put boxes on layers, switch between them in the layers panel, and give each layer its own layout. Layers.
- GPU boids: a flock written as a spec of kinds and rules. Studio tools from MADP.
- Edits that change a value in place, or arrive while a document loads, are now saved.
Interactive evolution, living strokes, and a livelier ALife page
More of the MADP studio tools arrived as starting points: GA, breeding pictures from short colour programs by clicking the ones you like, and Line, where each stroke you draw becomes a moving, sounding object. Studio tools from MADP. The ALife page now leads with what each system does and shows a real Lenia creature and animated agents, and the small languages are grouped in the site's navigation.
WebRTC streams in and out of Field
- WebRTC: publish a shader as a live stream, and receive anyone's stream as a texture, from Field or a browser, with or without a classroom server. WebRTC Streams.
charGrid { }: a grid of glyphs in an output panel, driven by a program that runs every tick, from a plasma to Life to a typewriter.- StackSL feedback: a StackSL program drawn against its own previous frame, and Tetra, pictures placed in a simplex by their CLIP embeddings. Studio tools from MADP.
- Box notes render numbered lists and wrapped list items.
ShaderToy-style shaders, particles and splats
New starting points rebuilt from the MADP studio tools:
- ShaderTrinket: a ShaderToy-style
mainImagein a box, recompiled with errors on their lines, with the webcam one line away. - Fern and Particles: points that accumulate and fade, iterated function systems, and particles you paint into the window with the mouse, steered by four GLSL hooks.
- Splat shader: procedural clouds of splats, sorted by depth.
All are on Studio tools from MADP. The geometry { } builder
draws in a studio look with ambient occlusion and exports GLB
(A studio look), and AI4 can build geometry with it.
The canvas as a score, and geometry from triangles
- Score: a playhead sweeps the canvas, and each box draws and plays while the playhead is over it; drag a box to move it in time. Score.
- Geometry: a model as a recipe of triangles through a transform stack, drawn studio-lit and exported as GLB. Geometry.
- The Tour now starts with frames and FLines, and Looking at Data was rebuilt around Field's own data tools.
- The Klecks integration is gone; Patchy is Field's painting editor.
New Tour stops: connecting boxes, GPU graphics and data
- The Tour gains three stops: Connecting boxes, Graphics on the GPU and Looking at Data.
- The Macro Recorder was rebuilt as a panel with run, rename, delete, step and copy, and it now records creating, deleting, connecting and disconnecting boxes. The Macro Recorder.
- The sequence memory and Evolving Creatures pages gained a dance film and a video of an evolved crawler.
Filming the canvas
- Filming the canvas: fly through your bookmarks, or film the canvas frame by frame to an MP4, from a box. Filming the canvas.
- Saving: every persistent edit is now autosaved, not only edits to code files, and an
external edit that Field overrides is kept in
backups/. When your edit loses. - Notation can set frames, groups and styles from code and anchor a mark to a box. Drawing from code.
- Sequence memory continues a recorded dance, and the moving-around guide covers layers and Frame Selected. Moving around the canvas.
Continuing a gesture, and evolving creatures
- Sequence memory and forecasting: remember recorded gestures, recombine them, and continue one live, or forecast it with Timestral. Continuing a Gesture.
- Evolving Creatures: breed swimmers on a water surface and crawlers on a floor, and watch them move in 3-D. Evolving Creatures.
- Flow from old film: particle tracks become a dense flow, with the camera's weave removed. Flow from old film.
Mapper graphs, vector field topology and contour trees
Three more topology tools, each with an explorer starting point: Mapper graphs draw the shape of a point cloud (blobs, branches, loops) as a small graph, vector field topology finds and classifies a flow's critical points, and merge and contour trees record how a field's islands split and join as you slice it at different heights. Starting points now link the pages that teach them, and the LP fan becomes a map you can edit (The fan as a map).
Vectorizing line drawings, and tracking features through time
Two more optional geometry extensions, both offered in first-run setup and on the welcome page:
- Polyvector fields turn a scanned sketch into curves that carry on through crossings. Vectorizing line drawings.
- Feature tracking follows the peaks and pits of a changing field from frame to frame and through scale, and reads video files as images. Tracking features.
- Chaining them: ridges to a forest of curves, strokes to smooth curves. Chaining the geometry extensions.
- SolidCraft: building a part from code is now part of the main page. Build a part from code.
Principal curves through point clouds
A new optional extension fits smooth curves and trees through a point cloud or a photograph, with width and uncertainty kept apart and stiffness you can adjust live. Principal curves. The 3-D linear-programming material joined the main page (In three dimensions), example code was tidied on dozens of pages, and an error from an AI4 tool no longer derails the rest of the conversation.
Morse–Smale complexes, and SolidCraft parts from code
- Morse–Smale complexes: read an image as a landscape and get its peaks, pits, passes, ridges and basins as geometry; a persistence threshold keeps what matters, and you can adjust it live. Morse–Smale complexes.
- SolidCraft from Kotlin: build designs with sketches, sweeps along rails, lofts and surfaces. Build a part from code.
- Linear programs in 3-D: convex hulls of point sets as polygons and polytopes. A polytope from a point cloud.
solidPartstakes a panel, so one assembly can be drawn in every panel of a sheet.
Linear programs as curves, and editing a document from outside Field
- Linear programs as curves: the routes the barrier, primal-dual, PDHG, ellipsoid and simplex methods take towards a polygon's optimum, drawn as curves, fans and animations. Linear programs as curves.
- Editing from outside: find a box's files on disk, edit its code or shader in another editor, or add a box by writing a file, and see what happens when both sides edit at once. Editing a document from outside Field.
- Clojure boxes get sliders and checkboxes, values from parent boxes, and errors marked on the line that raised them. Sliders and checkboxes.
Every file in the reference has an overview
Source files across the reference now open with an overview of what they are for, and names in the descriptions link to their own entries. Example code on the FLine, animation time, Field probes and spectral pages was rewritten for reading, and the beat and pitch analysis figures are real captures.
Optimal transport, and Python boxes that behave like Kotlin ones
- Optimal transport: match two sets one to one, move mass with Sinkhorn, and measure how far apart two distributions are. Optimal Transport.
- Python boxes mark an error on the line that raised it and get sliders and checkboxes with Python callbacks. Python output.
- Painting, typography and sorting-network examples were rewritten with the new drawing helpers.
A lattice Boltzmann fluid and a forest fire on the GPU
Two new GPU simulations: a wind-tunnel fluid that leaves a vortex street behind a cylinder (A fluid: lattice Boltzmann), and a forest fire with four kinds of fire (A forest fire). The Gaussian processes page was rewritten.
History Lens is now Code History
- Code History: the per-line history zone in the editor has a new name, and its shortcut is
alt+shift+h. Code History. - Kits run on first open: a document made from a kit starting point runs its roles, in launch order, the first time it opens. Kits and Starting Points.
- Corpus microscope: a neighbour can be placed on the canvas as an audio-clip box. Place a neighbour as a box.
- Shader templating pulls in another property with
{% property "name" %};{% include %}still works. Shader templating.
Example code rewritten across the site
The example boxes on many pages were rewritten to be shorter and easier to read, with Kotlin's collection literals and background work that stops with the run that started it. The Functions, polytope, keyframer, Manifold and statistics pages changed most, and Paint settings, swept was recaptured throughout. glTF texture transforms are now applied (glTF loading), and λ-term reduction follows Lambdascope, so shared structure reads back correctly (Reading back a shared answer).
Line notes for Kotlin boxes, and background work owned by its run
- Line notes now appear in Kotlin, MorphoHDL and Nano boxes, as they do in Field's other languages. Line notes.
runAsyncstarts background work whose callbacks stop when the box is stopped or re-run. Execution reference.- Editing files outside Field: external edits to a document's property files are applied to the open document. The document on disk.
- First steps: the live edit is now an assignment you run with Alt+Enter while the drawing moves. First steps.
- Docs prose is left-aligned and hyphenated, and the StackSL conversation was re-recorded.
Timed OSC bundles, and MIDI into Pure Data
- OSC: send timed bundles with
sendBundleandsendIn.osc(port)says when another program already holds the port, and a box's handlers go away when the box is deleted. Bundles and timetags. - Pure Data:
connectMidiwires hardware MIDI ports to a patch. Messages both ways. - Faust: a
buttonis momentary, and[scale:log]and[scale:exp]set a slider's law. The controls are the program's own. - Clearer errors in StackSL, Forth and Python boxes. Leave
cyclesout and a Sonic Pi loop is as long as the pattern takes to repeat. Sonic Pi.
Document-wide reactive properties, and many rough edges fixed
rootPropUp,rootPropDown,rootPropUpDownmake reactive slots for the whole document. Properties that re-run boxes.- Scrolling over output: the mouse wheel pans and zooms the canvas through an output panel that does not scroll itself.
- Keyframes: Simplify moves lanes that share key times together, and saves keep Booleans and whole numbers. Simplifying and smoothing a take.
- Cloth flattens visibly by default, and runs that diverge say so. Physics.
Motifs and discords: the matrix profile
A new page on the matrix profile: find the repeated shapes (motifs) and the odd ones out (discords) in a signal, compare two signals, work across several channels, and find what one set of recordings has that another lacks. Motifs, Discords and Contrast. Clojure boxes now name the symbol that failed to resolve (When something throws).
Field's library reorganised by subject
Field's Kotlin library now sits in packages grouped by subject, so an explicit import such as
afield.paint.* becomes afield.graphics.paint.*; every example on the site was updated. The
reference follows the new layout, lists every source file, opens with a chart
of the code by area, and gains pages for networking,
lighting and examples.
Properties that re-run boxes, and SolidCraft
- Reactive properties:
propDownreruns the boxes that read a value when it changes, andpropUpruns a missing value's supplier first. Everypropform takes a default. Properties that re-run boxes. - Faster re-runs: running an unchanged box again re-evaluates it instead of compiling it again.
- SolidCraft: an optional bridge to edit a CAD part's design and see the part in a box. SolidCraft.
Running go { } blocks show on the box
A box with go { } jobs still running shows a small badge with their count, and Alt+1 relaunches
just the part of an already-run box under the cursor.
Calling suspend functions. The synth's
delay() effect is now delayEffect(), so delay inside go { } waits as expected. Shortcuts
across the docs are spelled ctrl/command and alt/option.
A live terminal in a box's output
terminal() opens a real shell in a box's output panel. Box code can type into it and wait for a
program to start, print something or exit, so a command-line tool becomes something a box drives.
A Terminal in a Box walks through it.
Patchy, a layered painting editor inside a box
- Patchy: an optional layered painting editor that runs in a box's output panel and saves its paintings in the Field document. Your Kotlin code and the AI chat can paint on the same canvas you paint on by hand. Patchy.
- Traffic on the GPU: the Biham–Middleton–Levine traffic model as a compute-shader lesson, and the DLA lesson now grows 300,000 walkers on a 1024×1024 grid. Traffic.
go { }calls suspend functions from a box, and stopping the box cancels them. Calling suspend functions.
Guides with several steps, and exact curve booleans
- Interactive Guides, rewritten: the page now opens with a multi-step guide, then covers moving between steps and running code as a step opens or closes. Links in a guide's notes drive it on screen. Interactive Guides.
- Exact booleans and offsets for
FLine:booleanExactcuts outlines where they cross and keeps the pieces of the curves you drew, and cubic offsets come with joins. Exact booleans and offsets. - Replaying a gesture as paint: a take recorded on a gesture pad, or its edited keyframe lanes,
can drive a brush, including tilt and twist. The
gesture_paint_replaystarting point shows it. - One workspace per checkout:
./field.shremembers the last workspace for each checkout, not one for the whole machine. Your workspace.
Open Anything searches the documentation
Open Anything (cmd+p) now finds documentation pages and starting-point documents as well as
the boxes in your own document. The command palette and Open
Anything. The moving-hair brush learned
clumping, liquid bridges between hairs and a scattered splay, and dry bristles that ride the
paper's tooth; Paint settings, swept shows each one. Field also moved
to GraalVM 25.4.
Measuring, trimming and crossing FLines, and every paint setting swept
- Measuring along a line: ask an
FLinefor the point at a distance and get its position, tangent, normal and curvature; trim or split by distance, and find where lines cross, including a single curve that crosses itself. Measuring along a line, Trimming and splitting, Crossings. - Paint settings, swept: a new page that varies one paint, brush or drying setting at a time and shows what each does, next to an ordinary brush. Paint settings, swept.
- The Electron window names the documentation tab Documentation.
A page on box output, and browsable trees and logs
- Box Output: a new page on
print,display, output channels and opening, closing and clearing panels. Box Output. tree(),column()andlogs()page through large collections, open data classes and arrays, flag cycles, and take a query in their filter box; each row can copy its path. Trees and columns.- FieldML reads and writes reactive inherited properties. FieldML cheatsheet.
- AI documentation polish now shows the drafts card and the docs pass with captures.
MorphoHDL leads with usage, and circuit search gets its own page
The MorphoHDL page now starts with how to write and run a circuit, and the evolutionary circuit search moved to Searching for MorphoHDL Circuits. Pages across the site link their demo documents as starting points you can open, and the spatial geometry, ALife and starting-point gallery pages were tightened. In the Electron window, utility tabs are capitalised and tinted.
Sliders you can type into, and Code History under the line
- Controls: sliders take fine Shift-drag, keyboard nudges, a reset, and typed values, with tick, default and zero guides; vec2 pads and colour readouts accept typed values too (Handling a slider).
- Code History shows what one line said in earlier saves, under the line in the editor, including its first value.
- SolidSL fitting uses L-BFGS throughout (solid notation).
- The pattern rewriting and language extensions pages were rewritten, and many graphics, AI4 and beginner pages, among them Your first five minutes, now read more plainly.
Tuning by Gaussian process
- Tuning by Gaussian process is a new page: Bayesian optimisation when each try is slow, and A/B preference learning when the judge is you.
- More starting points: nine more docs demos open from the Welcome page, whose thumbnails now expand on hover.
- The Python page was rewritten for users, and boxes can use the polytope, audio AI and Loris libraries without importing them.
Box imports that tidy themselves
- Box imports: Format Kotlin now drops redundant and unused imports, and the editor folds the imports away.
- Drawing with Gaussian processes gained a closed loop with draggable pins and conditioning sliders (gp_drawing).
- The StackSL examples, RectSL cheatsheet and RectSL inverse animation pages were rewritten to lead with use.
Gaussian processes, SMPTE timecode, and staged projects
- Drawing with Gaussian processes is a new page: pin a curve or a field at a few points and draw the ways it could pass between them.
- SMPTE Timecode is a new page: read and write LTC and MIDI Time Code, and run a clock from either.
- Start a staged project is a new page: a starting place for projects built in stages, where an early change makes later results stale.
- A pattern in space now plays a head-tracked binaural render, and the mini-notation examples in Patterns play real Dirt samples.
Kits, qualified sources, and properties that pull and push
- Kits and Starting Points is a new page: package reusable tools and named starting points, add them once in Welcome, and make documents from them.
- Change a rule without breaking what already works is a new page: a rule changes only after a replay of the cases it already handles.
propUp,propDownandpropUpDownpull missing values upstream and push changes downstream, and box-to-box property reads can be drawn as a layer.- How Field Is Built is a public tour of the build machinery, and stippling places blue-noise dots that follow an image's tone.
Builds that AI4 can wait for
- Let AI4 Wait for Long Builds is a new page: AI4 starts a long derived build, ends its turn, and resumes when the result is ready.
- Study builds gained gates, per-attempt requests, dependencies across runners, resuming from an earlier attempt, and pruning (Studies).
- Sixteen docs pages now link their demo as a starting point.
Network MIDI, and phase noise in StackSL
- Network MIDI is a new page: Field joins AppleMIDI (RTP-MIDI) sessions to receive and send notes and controllers over the network.
- Phase noise: StackSL gained
qnoise,phnoiseandphrot, noise whose octaves you can turn by phase. - AI4's tool descriptions were rewritten, so it reaches an answer in fewer steps.
- The sorting networks, dynamic graph and wave function collapse pages were rewritten, and sorting-network plots now use Plotly.
Petri nets that throw sparks, and a state space as sculpture
- A Petri net that throws sparks is a new chain page: each firing plays a drum sample and throws a burst of GPU particles.
- A Deadlock, Sculpted and Traced is a new chain page: every reachable state of the dining philosophers becomes a solid, path traced in fog.
- Petri nets was restructured to start with music, then concurrency, drawing and limits.
- A box that was never saved is no longer deleted when its document's files change on disk.
Watercolour, and brushes with moving hairs
- Watercolour and ink is a new page: absorbent papers, wet-into-wet blooms and backruns, tilting the board, and pigments.
- Brushes with moving hairs is a new page: timed gestures and brushes whose hairs move, with knives, rags and spatter in Paint and pencil.
- GPT jams ORCA: AI4 plays the ORCA board while it runs.
ORCA in a box, and a watchmaker for shaders
- ORCA is a new page: Hundred Rabbits' livecoding sequencer runs in a box's output and sends its notes to your Kotlin; two ORCAs can play a duet with Kotlin between them.
- The watchmaker: a language model is shown the target and the best programs so far and proposes new ones, alongside a search you can steer and a gradient step on a program's numbers.
- Loris can now label, align and morph two sounds.
- The Faust and Sonic Pi pages were rewritten more plainly.
Loris partials, and evolving a shader toward a picture
- Loris: partial tracks and resynthesis is a new page: analyse a sound into partials, edit them, and resynthesise, with playable studies.
- Evolving a Shader Toward a Picture is a new page: genetic search over StackSL programs, scored by LPIPS perceptual distance.
- Simplify and Smooth clean up a dense keyframe curve, such as a shaky gesture take (The keyframe editor).
Reading saved AI4 chats
- Reading Saved AI4 Chats is a new page: read a saved chat as a tree, apply lenses to it, let AI4 write lenses, and browse them in the lens viewer.
- Meshes inside
moduleHere:moduleHere { +Mesh("name") { ... } }declares meshes in the module block. prop<>keeps the box's imports, and drag handlers can tell mouse buttons apart and report UVs.
Gesture takes become keyframes, and a faster Three.js viewer
- Gesture takes ↔ keyframe lanes: bake a recorded gesture into linked x and y lanes and back (The keyframe editor), with a gesture_to_keyframes starting point.
- Three.js geometry now travels as binary buffers, and changing a style no longer resends the geometry.
- LPIPS perceptual image distance is available through ONNX Runtime.
- A pattern in space was rewritten.
OSCQuery: controls other tools can find
OSCQuery is a new page: publish a box's parameters so other tools can find and
drive them, publish Field's own controls, and use another program's parameters. showMesh(path)
and showMesh(file) now take a renderer and say what they draw, and the
How to make sound page was rewritten.
MQTT, and a page for talking to AI4
- MQTT is a new page: read sensor feeds, publish, run an embedded broker, and pass messages on to OSC and DMX.
- Talking to AI4 documents push-to-talk voice input, which now restarts its worker after a timeout.
mesh(edges = true)draws a solid's outline in the Three.js viewer, and the polytope examples were rewritten.
Linked lanes in the keyframe editor
- Linked lanes: select a moment across several keyframe lanes and retime it together (The keyframe editor).
- The AI chat panel folds each run of tool activity into one line.
sourceBlock, code that keeps its own source, is documented in Running code in a box.- The geometry from disk and solid notation pages were rewritten to lead with the common case.
Your own key types in the keyframe editor, and a guided first run
- Keyframe editing: undo and redo, typed values, copy and paste, nudging, a library of 50 key
types, and your own key types with
interpolant("name") { }, whose shapes follow a drag live. - First-run setup walks through prerequisites with checkboxes for optional features, and installs them through winget or pacman where it can (Installation).
- Let AI4 drive a live webpage is a new page: a page in a box's output that you and AI4 work on together.
- The transcript gallery and chain pages show visual previews, and the Three.js viewer can play a looping shot with explode and X-ray moves.
The keyframe editor
The keyframe editor is a new page, with videos and a starting point: draw a value over time, edit the curve, simplify a performed take, and react to edits from code. Edited curves are now saved, and the panel is named after its curve. Kotlin completion no longer stalls the connection to the browser, and new editor commands rerun the enclosing block or just a number (Running code in a box).
Sequencer controls, and a gesture pad that records
- Sequencer controls: Max-style multisliders, matrices, range sliders and menus, straight or polar, with playheads you can script (Visualizers); the phone controller draws them too.
gesture(...)is an XY pad that records a take the box replays (Recording a gesture).- Manifold no longer frees a native object while a call is using it.
More canvas panes, and AI4's saved states
- Split canvas: up to three panes per axis, panes you can unlink, and thumbnails in the palette.
- AI4 saved states: browse a document's saved states beside the conversation, refer to them in chat, and fork them by name (AI features); Mermaid diagrams in replies preview inline.
flipboxswitches a block on and off with a checkbox in the editor, andaside { }holds code an ordinary run skips (Running code in a box).
Turntables and linked cameras in the Three.js viewer
- Three.js viewer:
turntable()turns a view for a display, and linked cameras move two views together; translucent meshes no longer hide what is behind them. - Subharmonic Synthesis gained tracked phase banks and harmonic analysis.
- The TetGen page was rewritten to lead with meshing, sizing and Kratos, and
OneEuroFiltertakes an optional sample rate for offline use.
Split the canvas, and your first five minutes
- Split canvas panes, spreadsheet-style: each pane shows its own part of the document, with draggable dividers, the drawing layer in every pane, and boxes that drag across a divider (Moving around the canvas).
- Your first five minutes is a new beginner page, starting from the moving drawing on the Welcome page, and Your code, AI and local history says what stays on your machine.
- Video particles turns a movie into trajectories you can inspect as polylines.
- A port that is already in use now tells you how to choose another.
Reset View, and Field remembers your last document
- Reset View (Alt+H) zooms back to 100% and closes every output panel (Moving around the canvas).
- Field remembers the last document you opened in each workspace, and new commands control whether the editor opens automatically (Keyboard shortcuts).
- Panning the canvas no longer stops when it crosses an output area, and completion lists package paths you have not imported yet.
- Installation now covers optional first-run Kotlin setup.
Kotlin extensions per project, and output pages that call their box
- Project-owned Kotlin extensions: Kotlin you reuse across documents can live in your own
project, set with
AFIELD_EXTENSION_DIRS, and boxes can import it (Installation). - Connecting an output iframe to its box is a new page: a page in a
box's output can ask the box's Kotlin to do something with
outputRequests. - AI4 chat has larger text, shows a live status while a turn waits, and messages you send while a turn runs reach that turn. AI4 can inspect your geometry notes.
- Output panels shrink back when their content does, and a box can call a local function as a statement again.
AI4 paints, and experiments you can branch and rewind
- AI4 Paints is a new page: ask for a painting, browse the saved ones, and
keep the brushes a conversation made, with an
ai4_paint_studiostarting point. - Experimenting with AI4 is a new page: write a tool mid-conversation, branch an experiment, and see what AI4 was told. AI4 conversations can now be rewound, edited and resent, and a document's chat is saved beside it and resumed after a restart.
- Tool programs: one call can run a small program over the other tools, shown as a trace in
the chat panel;
agentExtension { }adds live-coded hooks (AI features). - AI4 chat renders Markdown and sends on Enter.
Talking to AI4, and stipple transport
- Push-to-talk: hold a key and speak to AI4; a local Whisper model transcribes into the chat, on macOS, Linux and Windows (Talking to AI4).
- Stipple transport is a new page: a learned velocity field moves a sheet of particles into a stippled image, and can carry a grid or a curve along with them.
- Electron render-target views now work on Linux under native Wayland.
Values that outlive a run
prop, once and cached now have their own section in
Running code in a box:
a typed slot that children inherit, a slot filled the first time, and cached<T>(keys) { }, one
value per box for each set of keys. The LoRA generation page now
plays real audio beside a matched baseline, and the physics and
interpolants pages read more plainly.
Computer vision in Python, subharmonics, and graphics in an output area
- Computer vision in Python is a new page:
fieldcvbrings OpenCV and mediapipe tracking to Python boxes, sharing numpy memory with Field, with a webcam starting point. - Subharmonic Synthesis is a new page: add a tone a fraction below a line that is already playing, with three pitch trackers to choose from.
- Graphics in an Output Area: a render target can draw straight into a box's output panel in the Electron app.
- The Three.js output, output panel sizing and chart pages were rewritten to lead with use.
Drawn strokes become paint, and frames shared over Syphon
- Drawn Strokes Become Paint is a new chain page: pen strokes on the
drawing layer, with their pressure, become oil paint.
notationnow reads and writes per-point pen pressure. - Syphon is a new page: publish and receive GPU frames with Resolume, TouchDesigner, OBS and other Mac apps, with zero-copy receive.
- Examples that cross several parts of Field is a new overview of the chain pages.
- Snapping gained a palette toggle and row-aware even spacing.
A layers panel, Frame Selected, and streaming diffusion
- Canvas navigation: a layers panel (Alt+L), Frame Selected (Alt+F), and bookmarks that keep panel sizes and zoom and draw minimaps.
- Streaming diffusion is a new page: restyle a rendered texture with a text prompt, keeping the images on the GPU.
wiggledBywiggles one line along another, in 2D and 3D (FLine examples).- New workspaces no longer get a README copied into them.
Paint and pencil from FLines, and neural image rendering
- Paint and pencil from FLines is a new page:
PaintCanvasturns any FLine into simulated oil paint, a pencil line, hatching or stippling. - Neural image rendering with OpenDLSS-NR is a new page: draw into a texture, run a network over it and grade the result.
forever { }now resolves in a box without colliding with the renderer's own update loop.- The FLine examples introduce each signature before its code, and several chain pages were rewritten more plainly.
Csound boxes, and a bookmarks panel
- Csound is a new page:
.csdboxes run with Alt-Enter, with completion and hover from the manual, highlighting, line notes, offline render and MIDI. - A Drawn Morph, Heard is a new chain page: morph a drawn circle into a
heart and hear its size as a tune, using the new
matchPointspoint matching. - Bookmarks remember output panels, and a bookmarks panel opens with Alt+B (Moving around the canvas).
- The Sound page was rewritten to lead with its two voices.
Two-key keyboard chords
- Chords: a shortcut can now be two keys in sequence, such as Cmd+K Cmd+S (Keyboard shortcuts).
pulseTrain,easeandtweencan now be bounded and differentiated (Proving a Function's Range).- The Tour and the Functions gallery now show real captures, and the sound-path comparison plays real samples (How to make sound).
- Electron tabs are named after the page's file.
Proving a function's range, and a reorganised site
- Proving a Function's Range and Proving What a Shader Draws are new pages: interval arithmetic gives guaranteed bounds for a function, and for every pixel in a rectangle of a StackSL program.
- The site was regrouped: Moving around the canvas absorbs spatial navigation, the profiling timeline absorbs simulation time and frame budgets, and timeseries examples join the signal examples.
- Repository source paths in the docs link to GitHub, or open from your checkout in Field's docs pane, and inline code is highlighted like the reference tables.
Filled paths on the GPU with Slug
- Slug filled paths is a new page: a filled
FLinerendered as analytic curve coverage on the GPU, with a starter lesson. - The canonical graphics lessons are now a searchable starting point.
capture="ui"fences can set the window size and clip to a rectangle; the Survival guide and welcome page now show real captures.- The animation time model and history overview were rewritten.
September 2026
Lua boxes, and GPU schemas
- Lua in a Box is a new page: Lua runs in a box through LuaJIT, with completion that carries signatures, sliders and checkboxes that call back into the box's Lua, and sound through the pattern voice.
- GPU schemas let one Kotlin data class define a memory layout shared by the CPU and the GPU, with GLSL structs and buffer-reference views generated for you.
- Kotlin formatting and completion work again under Kotlin 2.5.
Studies, and asking why a value resolves where it does
- Studies is a new page: develop something that draws and keep a history of each accepted change, with a studies_rings starting point.
- Why does this value resolve here?:
why.speedshows which box supplied an inherited value, the path to it, and any ties or shadowed ancestors. - Notes on the docs: when you read these pages inside Field you can leave a note on any sentence, and notes are worked through page by page (Notes on the Documentation).
- AI4 can now look at what its boxes show (AI4's built-in tools).
Box code on Kotlin 2.5
Field and its box compiler moved to Kotlin 2.5.0-Beta1; val (a, _) = p now compiles in a box and
evaluation errors are reported. Spreadsheet formulas compile again and handle empty ranges
correctly, polytope faces and centroids read without index plumbing, and the StackSL WebGL2
preview accepts programs that use precise. The Three.js viewer
groups its parts and review controls.
A drawn score you can hear, and pressure membranes
- A Drawn Score, Heard is a new chain page: rectangles, a pen stroke and a level line on the canvas become a pattern.
- Pressure membranes: relax a closed mesh as a pressurised membrane with reinforcement, tethers and supports.
- AI4 in the chat panel gained box-graph and execution tools on every chat path, and can test a candidate edit before applying it (AI4's built-in tools).
- Field now exits on Ctrl-C or
kill -INTeven when launched in the background, saving pending edits first. KosmicKrisp is now the default Vulkan driver on Apple-silicon Macs running macOS 26.
Tools that boxes give the AI, and shader reloads that keep their state
- Box-authored AI tools:
aiTool { }registers a tool the model can call, owned by the run that registered it (Give the AI a tool of your own). - Stopping a box now releases what is running while keys and controls stay.
- Shader reloads compare the old and new interfaces, carry values across by name, and say what changed where you are looking.
- StackSL and RectSL studies share one set of tools for comparing and sweeping variants (Studies).
A drawing layer over the canvas, and notation that box code reads
- Drawing and Notation is a new page: an Excalidraw layer over the canvas that box code can read, write and react to, and read by intersection — a vertical line is an instant, a horizontal one a pitch.
- Canvas zoom: the canvas now zooms, and the drawing layer and background dots follow (Moving around the canvas).
- Point to geometry, keep the context: attach a note to a point, face or region in the Three.js viewer.
- Talking to the StackSL in your shader: fill a
stack.autoslot in your own GLSL by talking to AI4. - Inherited values now resolve through one rule everywhere, including the editor hover.
Pure Data patches, and line notes in every language
- Pure Data is a new page: Field runs Pd patches through libpd, marks an object Pd could not create in red, suggests fixes for typos, and lets Kotlin send to a Pd box.
- Line notes show what a line evaluated to in Python, Forth, Pd and other languages.
- A RectSL scene on a light rig is a new chain page: an animation played on an LED matrix and read back.
stack.autoslots can be shown and studied inside your own shader, and a box is now stopped before it is deleted or replaced.
Server-side completion for StackSL and RectSL, and ray-traced geometry you compute
- Completion and line notes for StackSL and RectSL now come from the compiler's whole vocabulary, including StackSL written inside Kotlin.
- Study cards use Field's sliders, named by what they change, with keys to capture and blend
settings (Talking a shader into existence); a
stack.autoslot's numbers live on the GPU with sliders on the box. - New NVIDIA pages: compute your ray-traced geometry, learn from a shader on the GPU, and Ray Reconstruction for the path tracer.
- The AI chat panel was restyled, with highlighted inline code.
Driving lights over Art-Net and sACN, and a page on OSC
- Driving Lights: Art-Net and sACN is a new page: a box can drive DMX fixtures over the network, or act as a lighting node itself, with a fixture-aware patch that draws itself.
- OSC and TUIO is a new page, with a fader that drives a drawing.
{a,b}alternatives in an address now match, TUIO blobs and bundle timetags decode correctly, and an exception in a handler now shows up in its box.
Talking a shader, or a scene, into existence
- Talking a shader into existence and Talking a scene into existence are new pages: describe a picture or an animation in AI4 chat, the model writes StackSL or RectSL in a box, and a window draws it live while you talk.
- GPU buffers now outlive the frames that use them, fixing a crash when a box freed a buffer mid-frame. When the renderer stops the boxes that draw into it, it offers to relaunch them.
- The StackSL gallery images now have correct colour.
Optical flow on every Vulkan device
- Portable optical flow: a pyramidal Lucas–Kanade backend runs on any Vulkan device, so the optical-flow starting points open on macOS too, with an optional forward–backward consistency map.
- A function, played and read back is a new chain page: play a curve as loudness and as pitch, analyse the recording, and compare.
- Stopping a renderer now stops and waits for the boxes that depend on it before freeing the GPU.
Neural reconstruction, ray-traced direct lighting and learned shaders
A set of new graphics pages for NVIDIA hardware and beyond: Direct lighting with RTXDI area lights you can move while Field keeps drawing, neural reconstruction with DLAA and DLSS Super Resolution, ray reconstruction of the RTXDI samples, and how to wire them into a render graph; optical flow, and a learned shader function that trains a small network and runs it per pixel. The ray tracing examples were rewritten, Slang shaders are highlighted, and many more figures gained descriptive alt text.
Builds and docs that work offline
./field.sh --offlinebuilds from the dependency cache; LWJGL is pinned to a release, so a cached build no longer stalls looking for updates (Installation).- The docs load with no network: fonts and the code highlighter now ship with Field.
- Reference tables explain themselves: across 31 guides, each entry now pairs a highlighted example with a sentence on what it does, among them the RectSL, StackSL, FieldML and Petri net cheatsheets and the linear algebra API.
One viewer for functions, sounds and signals
- A single time-axis viewer now draws
Fn.plot, recorded audio and analysis views, with device-pixel bins, waveforms up close, a WebGL piano roll for large note counts and optional synchronised zooming (Visualizers). - Certified bounds: a function's plot can show a guaranteed band behind its sampled envelope, computed with interval arithmetic (Proving a Function's Range).
Dual quaternion skinning on the GPU, and a twisted limb weighed
- GPU dual quaternion skinning can be chosen per instance and avoids the "candy wrapper" collapse of linear blending; skinned_characters shows it in one draw call.
- A twisted limb, weighed and traced is a new chain page measuring that collapse as lost volume.
- Saved function conversations show their plots, with collapsible tool traces.
Talking a function into existence
Talking a function into existence is a new page: a workbench where you describe in AI4 chat how a set of signals should move, and each accepted change becomes ordinary Kotlin in a box, with a saved revision you can return to. AI4 box conversations are now saved with the document and resume after a restart. Figures across many pages, including Visualizers and Petri nets, gained descriptive alt text.
Flow grain, and GLSL that is highlighted
- Flow grain and motion is a new playground: grain and strokes driven by a resident world and motion history for the camera and objects.
- GLSL fences in the docs now use a real GLSL grammar.
- A compute-shader probe bench, gpu_probe_bench, checks a GPU pressure-projection chain cell by cell against a closed form.
- The ray tracing examples now match the code that renders them.
Which clock Marf reads, and what a capture can show
- Field clocks for
marf: the defaultAUTOclock and when to choose another are now described in A pattern as a function generator. - What a capture can and cannot show is a new page on how a capture of a visual example can fail, loudly or quietly, and how to tell which happened.
- The band labels on the pattern particles chain now mark the real centres.
A λ-term you can hear
- A λ-term you can hear is a new chain page: it reduces a λ-term step by step on an interaction net and turns each reaction into a rhythm.
- GPU skinning: rigged characters now deform in the vertex shader, so a crowd of 64 renders live; see skinned_characters.
- Between two trained fields: Neural particle systems now interpolates two trained fields to make a letterform in between.
- A runnable marf_demo document opens the function generator.
Neural particle systems, and patterns as function generators
- Neural particle systems is a new guide: a small network learns to move 300,000 particles into a picture you give it, with a neighbour grid, boids, and a learned interaction between particles.
- A pattern as a function generator introduces
marf(...), modelled on the Buchla 248: patterns drive sequences, envelopes, LFOs and trajectories through banks of stored values.
Skinned characters, and Kolakoski rhythms
- Skeletal animation: bones and weights read from a glTF, a joint palette evaluated at a time,
and linear-blend and dual-quaternion skinning. Open
skinned_characters and drag
timeto bend the rig; the path tracer can now render a skinned glTF too. - Kolakoski counts, Euclid places: a self-describing rhythm sets how many hits land, a Euclidean one sets where, in Patterns.
- The welcome document every workspace starts with now describes Field correctly and points at documentation that exists.
FieldML stage by stage
FieldML stage by stage is a new page that follows one program from tokens and syntax tree through types and evaluation to its value, showing where errors and completion suggestions come from. Sixteen more demo documents became starting points you can open from the transcript gallery, including the interaction-net λ-calculus demo.
A photograph made into a printable solid
- A photograph, closed and mounted is a new chain page: depth predicted from one photo becomes a closed, mounted object.
- Fitting a StackSL program: tune a program's numeric literals until it matches a picture, in StackSL examples.
- λ-terms on interaction nets: a lambda front end parses a term and reduces it on a net, in Interaction Nets examples.
- A summarised quadtree over a raster, as one GPU pass chain: four_summary_pyramid.
A pattern placed in space, and keyframes swept overnight
- A pattern in space is a new page:
patSpatialtags each event with a direction and distance and Steam Audio places it around your head; the listener can follow a tracked head. - Sweeping saved keyframes overnight is a new page: a directory of keys goes in, an archive of renders comes out.
- A GPU-driven virtual texture shows a whole directory of images as one wall: mega_texture_wall.
Spatial audio with no device, and GPU simulations as pass chains
- Offline spatial audio: OpenAL can now run in isolated contexts and render spatial sound with no audio device, described in How to make sound.
- Persistent passes: a pass chain can keep state between frames, enough for a stable fluid you paint into and a jump-flood distance field (four_simulation_chain).
- The RectSL cheatsheet now highlights its fences and leads every section with a worked snippet.
- The codebase reference now documents the pattern clock and what schedules against it.
Steam Audio in Field
Steam Audio 4.8.1 is now bound directly from Kotlin, with the left–right handedness of 2D sources corrected, so binaural placement is available to box code; it is the engine behind A pattern in space. The Languages reference gained file overviews for Datalog, morpho and the FieldML front end.
Walls for scripted alife agents, and a polytope sliced into layers
- Walls: agents with their own programs now live in a world with obstacles, swept collision and routed seeking, in Spatial artificial life.
- A polytope, canonicalised, and sliced into layers is a new chain page: a Conway polytope made canonical and cut into a printable layer stack.
- Plot tick labels no longer rotate, and the solid notation page was rewritten to lead with what it does.
Springs, flow matching, and Clojure boxes
- Springs, dampers, and a character with mass: one-line spring functions and a steerable movement model, with a playground.
- Flow Matching fits a velocity field that carries one point cloud toward another.
- Clojure in a box documents Clojure boxes, now with highlighting and ranked completion.
- A participating medium for the path tracer, with your own phase function: Progressive path tracing.
- Polyphonic Faust: a pattern can play a Faust voice at several voices at once (Faust).
- New chain pages: three-dimensional Life and a RectSL animation as a solid; new audio pages on MuScriptor transcription and generating with a LoRA; and an aperture playground.
Chains across subsystems
The first pages that follow one piece of work through several parts of Field, each hop checked:
- A polytope, cut open and traced: Conway polytope, Manifold Booleans, then the path tracer.
- Particles, welded and traced: cloth to a mesh to the path tracer.
- A cellular automaton you can hear: automaton rules read as rhythm and pitch.
- A pattern that moves particles: a rhythm driving a shader's push constants, every note on its own frame.
The path tracer samples its lamps, and can be inspected while it runs
- Emitter sampling: the path tracer samples emissive geometry directly, so small, bright lamps leave fewer stray specks, without adding bias. Sampling the lamps directly.
- An instrument for a running tracer, and replacing its integrator without restarting. Reading a running tracer and Replacing the integrator.
- Reference: a new Renderers page, and the synthesis, pattern and audio pages open with guided tours of their files.
Progressive path tracing
- Path tracing, new: a progressive GPU path tracer with glTF import, camera jitter, depth of field, depth fog, glass and temporal reuse. Progressive path tracing.
patCondensefinds the shortest mini-notation that plays a given rhythm. The shortest way to write a rhythm down.- Charts clip their marks to the plot and wrap a long note. Charts as FLines. The simulation stack has its own reference page.
Tetrahedral meshing with TetGen
Filling a solid is a new page on TetGen: meshing a solid into tetrahedra, sizing the cells, checking mesh quality, and passing the result to the Kratos simulator (Into Kratos), which can now run parameter studies. Patterns gain Kolakoski rhythms beside the Euclidean ones; Mini-notation.
Eye tracking, and Petri nets laid out by TALA
- Eye tracking on OpenXR, and a marker placed in the world from binocular gaze. Eye tracking on OpenXR and Place a world-space marker.
- TALA layout for Petri nets, with arcs routed around the nodes, and for laying out boxes. Drawing a net.
- The Kratos simulator gains structural analysis with quadratic tetrahedra and a structural playground.
A Tour of Field, and code keyframes that blend
- The Tour: the documentation's staging area became a guided Tour, starting at A Tour of the Interface, and Where to Go Next maps the rest.
- Blending two code keyframes: Field aligns two versions of a program and interpolates the numbers in them. Blending two programs.
- An optional Kratos thermal backend, with an interactive playground.
A profiling timeline
Profiling is a new page and tool: record a timeline of frames, named scopes, coroutine resumes and JVM stacks, see a heatmap in the box's gutter, and follow a stutter down to a line of your code (From "it stutters" to a line of your code). A read-only document now says so in the window, and nothing in it is saved. Many more pages were tidied.
Multi-resolution pass chains on the GPU
A post-processing chain can now mix passes at different resolutions and formats, each with its own inputs, and Field prints the plan, with sizes and memory cost, before it touches the GPU. The four_pass_chain demo blurs a scene at a quarter size and composites it back at full resolution. The mesh, projection, typography, Sonic Pi, Python, sound and Manifold pages were rewritten in plainer language.
Log channels, sinks and the console
Logging is a new page: how log lines reach their sinks, one rule for matching
channels, muting the console without losing lines, blocks, stat lines and the pinned console.
withSink brackets adding and removing a sink so it cannot be forgotten. Pages across the site,
from statistics and Python to Faust and Vision Pro, were rewritten in plainer language.
OpenAI's newest model by default, and plainer pages
The direct OpenAI provider now defaults to gpt-6-astra, and a reply says which model answered; Provider and key settings. Mirrored glTF nodes keep their mirror on the GPU paths too. The pages on graphics, FieldML, Faust, RectSL, solidsl, Vision Pro, ONNX, keyframes, physics, StackSL and others were rewritten in plainer language, and the Field 4 graphics lessons lost their section numbers.
Evolving artificial life, and switching AI providers without a restart
- Evolution over rule spaces: cellular automaton and other artificial-life rules become genomes, scored by the measures the page already uses. Evolution: searching the rule space.
- AI providers can be swapped while Field runs. Provider and key settings.
--read-onlyopens a document without writing anything back to its folder, useful for a document kept in a repository.- The pages on completion ranking, frames, linear algebra, graph queries, history, output panels, the 3D output, keyboard shortcuts and others were rewritten in plainer language.
What a document is on disk, and MIDI files
- A Field document on disk: what one save writes, which file wins when a document loads, and what happens when you edit the folder under a running Field. A Field document on disk.
- MIDI: read and write Standard MIDI Files, send and receive on live devices, turn patterns into MIDI, draw a piano roll as FLines, and render MIDI to a WAV.
- Keyframe browser shows your own keys and strikes through a slot the scope no longer watches. Browsing saved keys. An output panel you drag to a size keeps it.
.h2 explores any object, and nesting connects
.h2now explores a domain object's properties, not just collections, with hand-written views for boxes,Fn, FLines and exceptions, and drills into a nested value in place. The value visualizer. An.h2panel takes the width of its box, and.hon a vec4 shows all four components.- Nesting a box connects it to its container, and the connection survives reloads and history restores.
- How an output panel picks its size, for when one comes out the wrong width. Output panel sizing.
A browser for saved keyframes
keyframeBrowser(dir, scope = …) shows a folder of saved keys side by side: select a key to see
it, brush a range to filter, read timestamps, and plot vec4 values. With a scope attached,
Apply writes a key back. Browsing saved keys.
Comments on a shader's push constants now appear in Kotlin completion.
August 2026
Which file a path means
File management is a new page on how Field resolves a file name: where a
plain name is looked for, roots of your own, fallback files, globs, and how to see where a path
went. Keyframes gain typed local targets and controls that follow a key, and a Pair displays as
the a to b that built it.
Datalog in a box
- Datalog, a deductive database as a Field language: facts, rules and queries over the
document or any object graph, with
#whyto show the proof of an answer and#whynotto say why a goal has none. Datalog, from Why a fact is there. - Graph queries take a
/path shorthand, globs inside a segment, case-insensitive names and|. The slash shorthand. - StackSL on the CPU: an interpreter for the GLSL StackSL emits, so a program can run without a GPU. The Languages reference collects Field's small languages.
- A run that succeeds no longer erases the errors it reported, and splats can be live-coded into render targets.
GPU state across frames, and a browser you do not have to render
- GPU state: a three-box simulation that keeps its state on the GPU, ping-pongs it between frames and edits its force law as a string. GPU state.
- A headless browser tab you can read as data: text, attributes, counts, tables and waits. A browser you do not have to render.
- Volumetric noise for StackSL:
noise3,fbm3,warp3,curl3,worley3and 4D variants. Volumetric noise. ./field.sh --document <name>opens a named document directly, and a folded comment stays on one row in the editor.
A web browser inside Field's graphics
The Puppet Browser puts a Chromium page into a native window or a VR
panel as a texture, drives it from Kotlin, and can even show Field itself. On Linux, browser
textures travel as shared GPU buffers. Stopping a box runs its .end { } block again;
What happens when you stop.
Placing things by distance, and splats as data
- MDS and t-SNE for any distance you can write, including graph distances.
Placing Things by Distance.
smileMdsnow works on Apple Silicon. - Speech and spectral embeddings: plot a recording as a path through an embedding space. Speech embeddings and spectral embeddings.
- Gaussian splats can be read, edited, previewed on the CPU and written back, and a sequence of splat files streams as one scrubbable cloud. Missing formats and missing features.
Python in Field, and moving around the canvas
- Python boxes get a page: the Python root, one shared namespace, output, notebooks as a column of boxes, and mixing Python and Kotlin in one document. Python.
- Moving around the canvas replaces the bookmarks page, with panning, stepping between boxes and bookmarks in one place. Moving Around the Canvas.
- solidsl solves for the numbers: fit a solid's parameters to a point cloud. Solving for the numbers.
- Compressed PlayCanvas splat files load directly, and a long comment in the editor folds into one panel.
Pointing at geometry, and the Vision Pro page
- One pointer for mouse, controller and pinched hand, which tells you which part of the geometry you touched. Hand tracking.
- Vision Pro: the page now covers the pose uplink, rendering from the head's own pose and where the streaming latency goes. Where the latency goes.
- Field's source on the docs site: a source citation in the docs is now a link to the file. The site's navigation was regrouped, and Running Code in a Box took over from the old pipeline page.
Hand tracking and head-tracked rendering
OpenXR hand tracking reports per-joint poses and pinch strength, and a Vision Pro can stream its
head pose back so Field renders from where you are looking.
Head tracking. A chorded launch now joins one
queue, so a later gesture extends the sequence, and the graphics examples use by keyCamera(...) for their
cameras again.
Cloth, rope and wind, and the graphics lessons extended
- Physics: the Verlet solver gains colliders, tearing, wind and gusts, and
Strandfor rope. Physics, starting from The two knobs are one knob. - Graphics on the GPU: the worked lessons now continue past texturing, through glTF, render-to-texture, ping-pong, blur, shader includes and debugging. Field 4 graphics.
- The corpus microscope indexes an audio corpus and places a neighbour as a box. Corpus microscope.
Charts as FLines
chart()draws marks, scales and ticks as FLines, charts a DataFrame's columns, and draws distributions and small multiples that share a domain. Plotly is still the first choice for interactive plots. Charts as FLines.- A physics system in the frame loop, with a recorded cloth. A physics system in the loop.
- The RectSL musicality section now shows its examples as animations.
DataFrames in a box
- DataFrames get a page: how typed columns survive from one run to the next, and what
.hand.h2show for a frame. DataFrames in a Box, fromtyped(): the way across. .h2on a list of same-shaped maps shows a table instead of a column of summaries.- Cloth, a reusable cloth patch for the Verlet solver, with its own debug view.
Cloth.
Types every box can name, and DataFrame's compiler plugin
A class declared in one box can now be named by every other box in the document. Kotlin
DataFrame's compiler plugin runs in box code, so a DataFrame's columns stay typed across
executions and a DataFrame displays as a first-class value.
DataFrames in a Box shows the result. facts() gives a
quick label-and-value summary for your own toHTML.
A pattern plays a polyphonic Faust instrument
A pattern can now play a Faust program polyphonically, with notes landing on the exact sample, and it can play any parameter, the filter cutoff as well as the notes. A pattern plays it. Petri net state spaces are faster to explore, and the state-graph drawing gives up cleanly on very large graphs (Checking every possible order). The polytope page was tidied.
What Field exposes to the network, and FieldML source macros
- Server surface: a page on what Field listens on, what a website you visit can and cannot reach, and how to connect another device. Server surface.
- FieldML source macros:
prop,moduleHereand other box-code macros work from FieldML, enough to build a live Vulkan scene. Source macros. - Tables from boxes and from the docs now share one renderer.
Frames and the animation loop
- Frames, a new page on
loop,foreverandframes, time in seconds, what happens when you stop, and the generator layer. Frames and the Animation Loop. Stopping a box now also stops a subprocess it started. - FieldML can satisfy Kotlin
suspendfunction types and use named arguments, so it can drive a moving Field 4 scene. Calling a suspend method. - RectSL inverse animation covers headings and the whole gallery, with
atan,atan2andhypotfor function graphs. Inverse animation.
How the completion popup decides
A new page follows one caret from keystroke to popup: how candidates are ranked and grouped,
how to put your own class's members first with @CommonMembers, and how to ask the popup to
show its reasoning. How the completion popup decides. The AI now
refuses an ambiguous box name instead of editing the first match.
A page for Field's 3D output
Field's 3D Output is a new page on the three.js output area: scenes, the camera, contact sheets, and which renderer draws what. A mesh can now be picked, sectioned, exploded and measured against an FLine; Measuring and sectioning a solid. The solidsl page gains a starting point and figures.
A notation for solids, and depth and CLIP models in a box
- solidsl, a written notation for 3D solids with two lowerings, a simplifier and a GLSL raymarch backend. A Solid, Written Down.
- ONNX models: depth estimation and CLIP run in a box, with cached sessions so a box can re-run cheaply. Depth & CLIP.
- Mesh repair: Field says why a mesh is not a solid, shows where, and repairs it with a report. From a file on disk to a solid.
- Hyperbezier curves, a drop-in alternative to
cubicTo. Hyperbezier. Meshes now open in the three.js viewer by default.
Robust mesh Booleans with Manifold
Union, difference and intersection of meshes, 2D sections and offsets, solids from a field and slicing back down to 2D, all through the Manifold library. Solids & Booleans (Manifold) is a new page, starting at Booleans. Invalid input comes back as a status you can read rather than a crash.
Field hears pitch, and audio renders feed analysis
- Render, then analyse: a pattern rendered to audio can go straight into the analysis views. Rendering a Pat pattern and analysing it.
- Synchronized audio analysis of a recording in several views at once. Audio AI analysis.
- From audio back to a pattern: Field tracks the pitch of a render and writes it out as notation. Sound.
- The audio stack is in the reference: Synthesis and Patterns.
Faust boxes, and every way to make a sound
- Faust: a box can be a Faust signal processor, with errors on the line, completion for the standard library and its own controls. Nothing to install. Faust.
- Sound paths: one page comparing every way Field makes, sends and receives samples. Making a Sound, Every Path There Is.
- Sonic Pi as a sequencer for Field's patterns, sample-exact. Field patterns as a Sonic Pi sequencer.
- Controls: sliders take a law (log, taper, bipolar), and a momentary button and a level meter join the controls. Controls.
Sonic Pi boxes, AI tools of your own, and a 3D inspector
- Sonic Pi v5: a box can be a piece of Sonic Pi music, with errors on the line and the line that is sounding highlighted. Sonic Pi.
- Your own AI tools: a box can register a tool that Field's AI can call. Give the AI a tool of your own.
threeInspectadds measurement, sectioning and an explode scrubber to the 3D output area. The 3D output area as an instrument.
Geometry from disk, and figures that know what you clicked
- Geometry from disk: OBJ, STL, PLY and glTF files load into a box, render, and write back out, with a table of what each format loses. Geometry From Disk.
- Clicking a figure tells you which element you hit, and where along it, in both the 2D and three.js views. Where on the element you clicked.
Notes on the documentation pages
The documentation shown inside Field gets a layer for leaving notes on a page, which persist and stay anchored to the text they were written against. Writing a note. Value visualizers show physical units, and completion records which suggestions were offered and taken.
Sound: from a pattern to audio
- Sound, a new page that follows a pattern all the way to audio, using real drum samples. Sound: the Pattern → Audio Path.
- Petri net state space: deadlock, boundedness and dead transitions answered exactly, with a counterexample drawn over the state graph. Deadlock and starvation.
- FieldML callbacks: a lambda passed to the JVM gets typed parameters and completion. Passing a function.
- Cmd+/ comments code again when the editor has focus.
Petri nets as a sequencer
- Petri nets that play rhythms, act as patterns, carry tokens with rhythms of their own, and drive control signals. Petri nets, with a cheatsheet.
- The audio gesture board: sketch a gesture and generate audio conditioned on a source. Gesture board.
- Patterns render offline with the real Dirt sample library. The real samples.
FieldML calls into the JVM
FieldML boxes can call Kotlin and Java methods, pass functions, and reach Field 4, with completion on the members of a typed JVM value. FieldML host bridge, from Calling a method. Completion at a dot now ranks names by where they are declared.
A FieldML cheatsheet, and FieldML that animates
- FieldML cheatsheet: one page of syntax, operators, lists, vectors, lines and JVM interop for Field's built-in typed language. FieldML cheatsheet.
- Iteration, vectors and per-frame animation in FieldML boxes, described in Animation and Vector arithmetic.
- Cmd+C in the editor copies text again, and a cancelled stream can no longer leave a browser tab stuck. Code completion offers more of the right names after a round of fixes.
- The inverse-animation page now shows its boxes running.
Inverse animation: say where a rectangle should be, solve for the numbers
RectSL can now work backwards: declare an unknown in a scene, say where a rectangle should be at a given moment, and Field fits the value by gradient descent through the animation. Inverse animation is a new page, starting at Declaring an unknown. The polytope page covers faces with holes and chained Conway operators, and the loadable demo index lists every scene.
RectSL scenes on the GPU, and rhythm as scene structure
- Distance fields: a RectSL scene can be lowered to a GLSL signed distance field and rendered live on the GPU. The scene as a distance field.
- Musical structure: Tidal-style pattern notation can drive a scene's rhythm. Musicality, with matching entries in the RectSL cheatsheet.
- Polytope faces with holes, and the whole Conway vocabulary chains. A face can have holes.
- Check for updates reports more reliably what an update would bring. Updating.
Rebindable keyboard shortcuts, and a page for the pattern language
- Keyboard shortcuts are now listed in full and can be rebound from a file Field writes for you. Keyboard shortcuts, from Writing a shortcut.
- Patterns get their own page: mini-notation, rhythm transforms, groove, per-event probability and patterns of patterns, with audio. Patterns. A rhythm can also be a node in a function graph, so a fit can tune it: A rhythm as a curve.
- Ceres builds and loads on Windows and Linux as well as macOS.
- The Field Audio service reference lists its operations, job states and error codes.
Polytopes and the Conway algebra
- Polytopes, new: build solids from Conway operators, keep track of where every face came from, and realise them canonically, in rank 4 as well as 3. Polytopes & the Conway algebra, with Realization using Ceres.
- Field Audio AI: variations of a source sound, gestures, and an EnCodec round trip. Field Audio AI.
- Audio analysis views beside recorded audio. Recorded audio.
- Interpolants on a frame clock, so an offline render eases the same way every time. Interpolants.
Typography as geometry
Text becomes geometry: a string turns into contours you can lay on a curve, animate, extrude, or treat as a distance field or a point cloud. Typography as geometry is a new page. Image convolution got faster, and now beats OpenCV on several filters; Speed, against OpenCV has the numbers.
Keyframes that capture live state, and Markdown in output panels
- Keyframes: capture a box's live values, save them as history, replay them, and drive a GPU uniform from them. Keyframes.
- Markdown output:
markdown("name", text)fills a panel the waydisplaydoes. Displaying into a panel. - Imaging visualizers: images, edges, corners and flow draw inline.
Images, edges, corners and flow.
showHeatmapdraws a heatmap in one call (Signal examples). - Searching for MorphoHDL circuits by generation and evolution. MorphoHDL in Field.
July 2026
Automatic differentiation, dynamic graphs and MorphoHDL
- Differentiating functions: reverse- and forward-mode differentiation, exact gradients for
Fngraphs, SGD, Adam and L-BFGS, inverse kinematics and circle packing. Differentiating Functions. - Graphs that change while you watch: dynamic graphs over moving points, drawn as FLines. Graphs that change.
- MorphoHDL circuits compile and simulate inside Field. MorphoHDL in Field.
- Dashes from
byDashingfollow the curve instead of cutting across it,src/personalcode reloads without a restart, and one broken language grammar no longer takes the editor down.
Artificial life, plane geometry and statistics
Three new pages:
- Spatial artificial life: Life, cyclic automata, reaction–diffusion, Lenia, boids, Physarum, diffusion-limited aggregation, L-systems and evolved rules.
- Voronoi, contours and clusters: Delaunay and Voronoi, Apollonius diagrams, contours of a field and clustering, with FLine output.
- Statistics & dependence: summary statistics, histogram bin rules, dependence coefficients and rolling correlation.
Plotly legends no longer sit on top of the data, and showImg keeps its caption.
Wave function collapse, rewritten
The Wave Function Collapse examples page was rewritten. Learned
overlapping patterns can now be closed under rotation and reflection with expandSymmetry, and
Neighborhoods beyond von Neumann shows
larger neighbourhoods. Callout boxes on the docs site now render as boxes.
Triangle meshes and wave function collapse
- Mesh examples: a triangle-mesh library with no outside dependencies, for modelling from a field, subdividing, smoothing, decimating and measuring, with an inline view of each mesh.
- Wave function collapse: a worked example, with the solver and its rules drawing themselves as you inspect them.
- Vision Pro geometry can be previewed on the Mac before it reaches the headset (Vision geometry), and the imaging library is compared against OpenCV (Imaging).
- Corrections:
movingAveragenow returns a mean,tilereports its true extent, and the rank helpers behind rank correlations now sort; the reference documents far more of the library.
A codebase reference, and an imaging library
- Reference: every public declaration in Field's library, grouped by area, generated from the source and its KDoc.
- Imaging examples: a CPU imaging and computer-vision library for filters, edges, corners, Hough lines, blobs, warps and motion, whose results become FLines.
- Vision geometry: building meshes that run natively in a Vision Pro head, now tried on a real device.
- Typing in the Electron app no longer stalls while canvas history is captured.
Synth building blocks you can hear
Dough DSP sound is new: reverb, phaser, a resonant low-pass, envelopes, distortion and raw oscillators, each with a plot and a recording you can play. Long examples on the docs pages can now fold their setup code away, so the idea shows first.
Rewriting code with patterns
Pattern rewrite is new: write rewrite { } rules that match Kotlin
expressions and replace them before a box compiles, with guards, variadic holes, code that runs
at rewrite time, rules inherited by child boxes, and a small language of
strategies for choosing
where and when rules fire.
Querying object graphs by path
Querying object graphs is new: graphPaths searches a live object for values
by pattern, rather as XPath searches a document, with predicates and typed lenses, and
params() turns what it finds into numbers you can drive. In
RectSL, every word that changes the scene now starts with ->, so a
program shows where it mutates; the examples were rewritten to match. RemoteAR and Vision Pro
gained starting points you can open from the welcome page.
An AR head inside a box
remoteAr() embeds the WebXR head in a box's own output, so you can see and draw into it
without a second device (AR reference), and
named scene slots are typed. A fresh clone now builds the first time field.sh runs
(Installation).
Kotlin in the head, and rewrite rules in a box
- Kotlin in the head is new: write a box in Kotlin and run it in a browser head as JavaScript, drawing with Three.js, playing Tone.js or driving Metal.
- Rewrite rules (
rewrite { from ... to ... }) can be used inside a box, and a box's rules apply to its children (Pattern rewrite). - RemoteAR scenes gained motion and assets, and Kotlin/JS completion leaves out JVM-only names.
Tone.js music, and ImGui inside VR
A Kotlin/JS box marked // {{ tone }} drives Tone.js for synths and sequencing
(Kotlin in the head), with launch and stop handled
like any other box. ImGui as an in-VR panel is new: an ImGui window
floating in the headset, aimed and clicked with a controller.
Kotlin boxes that run as JavaScript
A box can now be written in Kotlin and compiled to JavaScript for a browser head, with
highlighting and completion and no fun main() wrapper
(Kotlin in the head). The RemoteAR
surface grew vector maths, transforms, cameras and pointer callbacks on FLines. The welcome
page offers the bundled templates as a starting-point group
(Templates), and a Vision Pro head runs
Metal on its own (Field on Apple Vision Pro).
display shows images and plays sound
display(...) now accepts PNG, JPEG and GIF bytes as pictures and WAV bytes as a player
(Box output), and showSignals(...) plots several signals
together with Plotly. The Spectral examples page grew a resonator-bank
example and now renders live in Field. The AR reference was rewritten for
the updated RemoteJS WebXR head, and pointer input in remote AR works again.
State estimation and spectral analysis
- State estimation examples: tracking with an unscented Kalman filter and a particle filter, with captured results.
- Spectral examples: FFTs, spectrograms, mel bands and streaming features from a new frequency-domain library.
- Values over time was retitled and tightened, Plotly charts use Field's font and slimmer margins in the dark theme, and more chatty log channels are muted by default.
Bullet-hell patterns in RectSL, and a docs overhaul
- RectSL shapes can face the way they travel, live for a window of time, and split recursively into sprays (RectSL examples).
- The docs were merged and cut: Values over time, Linear algebra, Neighbours and graphs and Visualizers were rewritten, and Agent transcripts lists documents you can load and run.
- The welcome page shows a thumbnail of each document's history (Your history with Field); the function fitters accept your own distance measure, and on Linux the desktop mirror no longer caps a headset's frame rate.
Jupyter notebooks in and out
Drop a .ipynb notebook on the canvas and it becomes a column of Python boxes; export it back
again (Python). Python output was polished: long
output is truncated, tqdm progress bars draw, and arrays print faithfully
(Python). Dropping any file now offers a menu suited to its type, Kotlin
completion gained a new K2 backend, and RectSL can draw plots with axes and legends
(RectSL examples).
Charts in RectSL, and Python setup from the welcome page
RectSL gained colormaps, bar charts, heatmaps and scatter plots (RectSL examples). The welcome page can install JEP, which Python boxes need, into a virtual environment you choose (Python). Double-precision matrices display as heatmaps (Linear algebra), and the Field probes page now shows its GPU demo running.
How box code runs
- Running code in a box is new: macros, preambles, inheritance,
@exportedand the//%-fragment break, in one place. - RectSL gained arrays, a bridge to the Functions library and inline Kotlin (RectSL examples), live syntax highlighting, and readable compile errors.
- Dragging a box dims the editor and shows the canvas dots and axes.
- Pasted operation transcripts run on their own (Automating Field), and the AR reference was rewritten.
Fitting functions to a target
A graph of functions can now be fitted to a target by gradient descent, with fitBest trying
several starts (Functions examples).
Vectors gained GLSL-style swizzles and operators
(Linear algebra), there is a
full family of double-precision matrices, and error suggestions arrive faster.
Open Anything searches the docs by meaning
Open Anything now searches the documentation and Field's source by meaning as well as by name (Tour of the interface). Compile and evaluation errors stay pinned in the terminal, and noisy log channels are muted there by default (Logging). Connection lines are drawn behind boxes so a box's frosted background blurs them, the font settled on a semi-condensed Iosevka, and the generated vector types can be subclassed.
Field's own linear algebra
- Vectors and matrices are now Field's own generated types, with doubles as first-class as floats and concise constructors (Linear algebra, API).
- Values draw themselves: vectors and matrices get small geometric thumbnails, numeric arrays and lists get sparklines, and functions get an inline plot (Visualizers).
- Field from your phone is a new page on the phone control surfaces.
- Field's editor font is now a condensed Iosevka, and a macro can be promoted to a wider scope (Automating Field).
Browsing code from the completion panel
Names in the documentation beside a completion are now links: follow one to read its source, and keep going from there (Browsing code from the completion panel). Find similar code results show their source inline, as do semantic search results (The semantic index). Rectify, quantize and crush became waveshaping operations that evolution can use (Functions examples).
Field on Apple Vision Pro
A native visionOS front end shows FLines in 3D, edits them by hand, and receives Field's
rendered output as a video stream, side-by-side stereo included
(Field on Apple Vision Pro). In the Functions library, ramp now draws a straight
value line and the old normalizer is called remap; the Chebyshev waveshaper's order is
continuous, so harmonics sweep smoothly. AI completions no longer hold up the ordinary
completion popup.
Function domains, and a Chebyshev waveshaper
Function domains is a new page on where a function is defined and why oscillators run forever. A Chebyshev waveshaper joins the function transforms (Functions examples). The pinned log console can scroll back through earlier lines and shows network statistics (Logging), and the render stream to Vision Pro now works from Linux with NVIDIA's encoder.
A pinned console for busy log channels
Busy log channels can be pinned to a console in the terminal instead of scrolling past (Logging). Oscillators in the Functions library now have infinite domains by default (Function domains), the welcome page lists documents as it finds them instead of waiting for all of them, and the render stream carries a side-by-side stereo flag.
Waveshaping functions
Functions can now be folded, rectified and quantized like an audio signal is waveshaped, and a new section explains how the transform pipeline fits together (Functions examples). Completion after an infix operator takes overloads into account, and a render-to-texture target can be streamed as video from macOS to a headset (Field on Apple Vision Pro).
Evolving functions for variety
Evolution over function graphs can search for a varied set of results rather than one best answer, with a worked example that runs on the CPU (Functions examples). Boxes can show transient progress bars (Box output), and completion after an infix operator now knows the type on its left (Functions examples).
Galleries, history pages, and Field as an MCP server
- Galleries: rendered stills and animations for StackSL and RectSL.
- New pages: Your history with Field, Code history, the semantic index, Field probes, Automating Field and AI tool-use history.
- Error suggestions carry Apply and Ask AI buttons (AI features).
- MCP: Field runs as a local MCP server, so outside coding agents can use the same tools as its own assistant (AI features).
Inspecting and rewriting functions as graphs
- Function graphs: a function can be browsed through its component graph and changed with a small rewrite language (Functions examples); the page itself was rewritten around the transform pipeline.
- Fabricate moved closer to Three.js in what a scene can say (Fabricate renderer).
- Building the docs and running the tests is new.
- Reloading a page no longer fetches every static file again,
?nosplashskips the intro animation, and output panels no longer flicker while they size themselves.
Semantic search over your code
With a model configured, Field can index your code and find it from a description of what it does (The semantic index). The Fabricate renderer gained a post-effects stack, a scene graph and render planning (Fabricate renderer), the canvas background is drawn with WebGL everywhere, and exceptions thrown inside callbacks are now reported in the editor.
FieldML, and box output on your phone
- FieldML, a small typed expression language that runs inside Field, with completion (FieldML examples).
- Phone controllers mirror a box's output and its control groups (Field from your phone).
- Fabricate frame graphs can be inspected (Fabricate renderer).
- Where to go next was rewritten as a map of the docs, and Electron uses hardware acceleration on Linux.
Recorded operations, and a calmer start
Operations on a document can now be written down as data and replayed as macros (Automating Field). GLSL completion is much better, a formatting command knows which language each property holds, startup no longer floods the screen with messages, and notifications were redone. The full Iosevka font set now loads.
Maven dependencies, and faster starts
Boxes can pull libraries from Maven repositories, managed from a panel on the welcome page, which now also shows runloop statistics. Ahead-of-time caching shortens startup, reading a depth buffer is about a hundred times faster, Linux memory allocation was fixed, and OpenXR starts more cleanly.
June 2026
RectSL, and a new completion picker
RectSL, a small language for animated scenes built from rectangles, arrives with its cheatsheet, as the first language built on the extension mechanism (Language extensions). Completion now has its own picker, grouped by category. Field also listens on a local HTTP port, so scripts on the same machine can drive it (Automating Field).
Language extensions
New languages can be plugged into Field as extensions, with their own completion, embedded regions and notes on what each line did (Language extensions). AI prompts are kept in a document's history, backups no longer repeat themselves, and the KDoc behind completion was polished.
Shader probes, sourceBlock and file lookup
- Probes:
fieldProbereads values back from a running shader andfieldStatsgathers statistics on the GPU (Field Probes). sourceBlock { }is a block you call like a function that keeps its own source text (Running code).@rootExportedand@metarootExportedshare a definition across a document or every open document (Running code).- Files by name: code can find a file that travels with the document (File management). Error messages are clearer, and StackSL gained function pointers and sampler helpers.
Ableton sets, OpenRouter and more StackSL
- Projects and a metaroot: documents can share a root above them, so open tabs can pass values to each other (Kits).
- StackSL gained more words and named local marks (StackSL cheatsheet).
- OpenRouter joins the AI providers (AI features).
- Render-to-texture targets can be blitted straight to a window, including a debug view that leaves the target untouched, and Ableton Live set files can be read into a box.
The StackSL cheatsheet
The StackSL cheatsheet is new: every word of the little stack language for shaders, on one page. StackSL now also runs inside compute shaders. Elsewhere, controllers can be locked and edit 2D values (Field from your phone), render-to-texture targets can be saved as JPEG without stalling, granular synthesis improved, 24-bit WAV files load, and document search finds what it should.
OSC from the browser, and AI that runs Kotlin
OSC can now reach Field from a web page through a built-in bridge, and Field's own OSC
editor can edit by deltas. The AI assistant can evaluate Kotlin
and check a box's variables while it works (AI features). StackSL gained
bitcrushing and other operators, and the .h and .h2 views were tidied
(Visualizers).
The desktop app, ray tracing, StackSL and the first docs site
Four months of work arrived at once:
- A desktop app with tabs and a welcome page, plus the Tour, AI features, Visualizers and Interactive guides pages.
- Graphics: Field 4 Graphics, the Fabricate renderer, Vulkan ray tracing, HDR output, Slang shaders and a GPU radix sort.
- Languages: StackSL for shaders, Forth and Nano, on the K2 Kotlin compiler.
- Examples of functions, interpolants, sorting networks, boolean networks and their music, interaction nets and colours.
- History: document history and the code history lens in the editor, plus Jolt physics, a keyframe editor and spreadsheets.
February 2026
Graphs on point clouds, curve fitting and cloth
- Graphs: neighbour searches and graph families over a point cloud, with Voronoi and Delaunay (Neighbours and graphs).
- Fitting lines and curves to points (FLine examples).
- Physics: a particle solver with distance constraints and a cloth example (Physics), grabbable in VR.
@exportedpromotes a definition so connected boxes can use it (Running code).- Search Documentation & Code (Cmd+Shift+D) searches the docs and your code (Keyboard shortcuts), and the value visualizer shows more about images.
PLY point clouds, ImGui and documentation in completion
- PLY files load as meshes or point clouds (Geometry from disk), and glTF models carry their embedded textures.
- ImGui panels, in a window or inside VR (ImGui as an in-VR panel).
- Completion shows documentation for what it offers, and an API reference is generated from the source (Reference).
- Launchers you can double-click (Installation), Kotlin 2.3, a spatial audio engine, and a NumPy file reader.
January 2026
The first documentation pages
Field's documentation site began here: Installation, the Survival guide, a Kotlin overview for Python and JavaScript users, FLine examples, the diff player and the AR reference. A read-only viewer can now show a document without a running Field (today's published documents grew from it), and stereo output for OpenXR was fixed.
A Three.js viewer for lines
FLines can now be shown in an interactive Three.js viewer in a box's output, with orbit controls for turning the view; Three.js scenes describes what grew from it. Box code can also open, close and clear its own display channels (Box output), and many more geometry operations joined FLine.
Geometry operations on FLines
- FLine geometry: arcs, noise, offsets, curve combination and parameterization, over fifty operations on drawn lines, all called as methods on the line. FLine examples.
ImageReducerreduces an image with a compute shader, once or every frame (reference).- Side-by-side stereo output for OpenXR, and a stand-in headset for working without one.
Cmd Cmd to move between boxes, and AI completion
- Double-tap Cmd to step between boxes from the keyboard (Moving around the canvas).
- AI completion of Kotlin as you type (AI features).
- Action links in guide notes run code when clicked (Interactive guides).
- A first standard renderer, the quick path to a lit scene, with a set of standard shapes
(Fabricate renderer);
autorunboxes run when a document opens, and layers got a palette (Layers).
Layers
Boxes can be put on layers, and switching layers shows and hides them with an animation, each layer keeping its own box positions. Also new: the documentation browser inside Field, browsing a glTF scene in a box's output (Visualizers), and names for saved versions in document history.
Document history
Every save now becomes a version you can browse and restore from a timeline of the document's past (Document history). Saving now happens in the background. Guide chats can be shared and kept across sessions (Interactive guides), and the renderer's profiler now covers OpenXR headsets.
Snapping boxes while you drag
Boxes snap to each other's edges and centres as you drag or resize them, with cyan guides showing what they lined up with; Caps Lock turns snapping off (Moving around the canvas). Push constants can now be interpolated, and VR input sources were reworked so headset input is smoother.
Interactive guides with callbacks and chat
- Guide callbacks: links in a guide note can run code, and note text can fill in live values from the document (Interactive guides).
- Per-slide chat: a step can carry its own discussion (Interactive guides).
- Template descriptions show in the insert menu (Templates), and YAML metadata gets completion.
- Double-tapping Shift opens Open Anything reliably (Tour of the interface), and pasting nested boxes keeps them in place.
December 2025
Search across a document
A document-wide search finds text in every box (Tour of the interface). Images can be attached to an AI chat, the editor shows whether each box is running, sliders and other controls work inside output panels (Visualizers), and dragging boxes stays smooth when the frame rate is low.
The value visualizer and controls in output
- Value visualizer: values print as compact, readable views, with cycles detected (Visualizers).
- Controls: sliders, 2D pads, checkboxes, text fields and colour pickers in a box's output, each calling back into your code (Visualizers).
- Slideshow annotations: lines drawn from a note to a box or a line of code (Interactive guides), and slides can show images from the workspace.
- Output panels: Alt-click a panel's arrow to remove it, Shift-click to show it alone.
Slideshows, bookmarks and logging
- Slideshows:
slideShow { step(...) }walks through a document step by step with notes over the canvas (Interactive guides). - Bookmarks save a view of the canvas to come back to with a function key (Moving around the canvas).
- Logging built into Field, with channels and a browser for the log (Logging), and the running renderer can be browsed like any other value (Visualizers).
- Templates can come from a remote server, keep their nested boxes, and land where the mouse is (Templates); video plays with synchronised sound.
Templates, and editing a document from outside Field
- Save as template: save boxes and insert them again in any document (Templates), including from a shared template server (Templates).
- External edits: change a box's code in your own editor and Field picks it up (Editing a document from outside Field).
- Video textures: play a video file onto the GPU (reference).
- Export the selection or the whole document, import a
metadata.edn, and Alt-double-click a symbol to run it.
Nesting boxes, and OpenXR for headsets
Boxes can now nest inside other boxes (Tour), and VR moved to OpenXR (Field inside VR). GLSL got completion in the editor, the AI chat was reworked, and boxes written in languages other than Kotlin run more smoothly.
AI chat, and documents as EDN
An AI chat arrived inside Field, with streamed replies (AI features).
Documents are now saved as EDN, a metadata.edn plus a file per large property
(What a document is on disk). Boxes can be copied and pasted
(Keyboard shortcuts), and OSC support grew.
Render to texture, compute particles and OSC
- Render to texture, including ping-pong between two targets (Field 4 Graphics).
- Compute shaders and particles (Field 4 Graphics), several windows at once, and multi-texture glTF models.
- OSC in and out of a box, with handlers that run when a message arrives (OSC).
- Shader templating (Field 4 Graphics).
November 2025
Browsing values, and a keyboard camera
Values can be browsed as trees and columns in a box's output (Visualizers), and a camera you fly with the keyboard joined the graphics library (Field 4 Graphics). Stereo headsets render both eyes in one pass, and render targets can be layered.
Mesh shaders, glTF and Linux
The renderer gained mesh shaders and glTF model loading (Field 4 Graphics), plus a first VR target. Field now runs on Linux as well as macOS and Windows (Installation), and completion works on Windows.
Field·4 begins
Field·4 starts as a Kotlin live-coding environment with a browser canvas of boxes, a code editor, a Vulkan renderer, AI hooks and Python boxes, built for macOS and Windows. The Tour and Installation describe what it became.