The libcvc scene-graph library, rendering live in your browser — VTK 9.5 cross-compiled to WebAssembly.
The terrain lab rebuilt in the Ariadne UI DSL: one generated_world scene node (cvc::world's relief, L-system props, roads-first city and water, as a handful of merged meshes) and its Terrain Lab panel, which regenerates the world live. The scene block carries the fast render discipline of the CVC-DBG Austin convoy demo: a ground that receives shadows but casts none, an opaque ground texture, a sun shadow map that follows the camera, a key + fill rig with no extra shadow casters, and the soft afternoon look. The city grows from district cores: a graded street network (arterials, collectors, local streets that thin out away from the cores), lots backing onto each other along it, filled from the cores out, with the Austin building archetypes when their bundle is mounted and procedural buildings (town houses with gable roofs, blocks and the odd tower) without it.
Run it →
Fly over a procedural island: L-system trees swaying in the wind, a travelling-wave sea and a GPU ray-cast cloud volume, with shadow maps and a free orbit/fly camera. 100% procedural — nothing is downloaded.
Run it →
The lsystem_forest demo reborn in the Ariadne UI DSL: the heightfield island, its sand/grass/rock height bands, the sky-gradient background, the StageLighting rig and shadows are all declared in one .ari document on the reusable scene capabilities — no demo-specific C++. The procedural pieces that aren't declaratively expressible are custom scene-node types the host registers: the L-system trees (both the original conifer pine and a compact branchy species), the travelling-wave sea volume, and the drifting L-system + fBm cloud sky volume. The pines sway in the wind and the cloud casts a soft shadow on the ground. 100% procedural — nothing is downloaded.
Run it →
Sail a procedural coastline where a GPU FFT ocean rolls in: an FFT-synthesised wave spectrum evolved live on the GPU, an L-system shore, sky and sun, with a free orbit/fly camera. 100% procedural — nothing is downloaded.
Run it →
Two bunnies, two renderers: the classic mesh beside a signed-distance-field volume of the same bunny, raycast on the CPU by cvc::volren and composited into the scene with a per-pixel depth map — watch it occlude and be occluded as it spins. The SDF is computed live from the mesh at startup; the raycast image, its translucent shell and the raster resolution are all software, no GPU volume tricks.
Run it →
The same CPU-raycast bunny, rebuilt in the Ariadne UI DSL: the scene, lighting rig and raycast control panel are all declared in one .ari document — no demo-specific C++, just arigl. The volume is computed live as the signed distance field of the embedded Stanford mesh via a single DSL source (source: { sdf: { mesh } }), and the controls are reusable .ari components shared with the other bunny demos.
Run it →
The classic view-aligned slice compositor from VolumeRover2, ported to cvc::volslice: the bunny's signed-distance volume windowed into a byte texture and colored by a 256-entry transfer function, hundreds of camera-facing slices blended back to front. Add up to nine bunnies — each is its own scene-graph volume node, depth-sorted per frame — and drive quality, near-plane peel, the value window and spacing-corrected opacity live in the panel.
Run it →
The slice-based bunny, rebuilt in the Ariadne UI DSL: scene, transfer function, lighting and the slice control panel declared in one .ari document, run by arigl — no demo-specific C++. The volume is the signed distance field of the embedded Stanford mesh (source: { sdf: { mesh } }), and the controls are reusable .ari components.
Run it →
The classic orthoslicer beside a raycast volume, as one Ariadne document: the signed distance field of the embedded Stanford bunny, raycast with a see-through surface and cut by three axis-aligned volume_slice planes that share one volume and one transfer function. A slice view looks straight down whichever axis the XY / XZ / ZY switch picks: drag to pan, the wheel zooms about the pointer, a click reads out the voxel under it. The sliders move the planes, and the transfer-function editor recolours all three.
Run it →
VolumeGridRover rebuilt as an Ariadne component over a volume_grid node: the signed distance field of the embedded Stanford bunny in three slice planes, a slice view under the XY / XZ / ZY switch beside a 3D view of the planes, and a panel with the probe, the point classes and the transfer function. Click in the slice view to mark a point of the current class (or unmark one), drag to select points in a rubber band, Shift+Ctrl drag to move them; Navigate moves the other planes to the voxel clicked, and the probe follows the pointer.
Run it →
The VolumeRover skeletonization, ported to libcvc, on a mesh_lab node: the embedded Stanford bunny is decimated to 4,000 triangles and its vertices skeletonized (Tight Cocone, the medial axis, then the unstable manifolds of its saddles) a slice at a time on the page's scheduler, so the page keeps drawing while it runs. The strands (green, with blue stars) and the sheets are drawn inside the see-through surface, and a second view shows the skeleton alone. The Mesh tools panel's Skeleton section sets the parameters, runs it again with a progress bar and a Stop button, and shows or hides each part.
Run it →
VolumeRover's contour tiler as one Ariadne document: a contour_lab node reads a real Reconstruct series from mouse hippocampus (two axons traced through 72 sections, a third that branches, and two mitochondria inside one of them; Kuwajima 2019, CC0), draws the traced contours and tiles a surface through each object's contours, slice pair by slice pair, as a sliced task, so the page keeps drawing while it works and the progress bar names the pair it is on. Tick the components to tile, change the slice range or the parameters, and tile again; the surfaces are see-through, so the mitochondria show inside their axon.
Run it →
The FEM gallery, live: Poisson, heat diffusion and the vibration modes of solids tet-meshed by the LBIE mesher, surface curvature, geodesics and Laplace-Beltrami modes, and LBIE's own tet and hex meshes cut away and coloured by element size or quality, on the Stanford bunny, a scanned head and a Visible Human CT. Step through the items from the Gallery menu or with the arrow keys, then change any solve or mesh in its panel. libigl solves it on cvc::fem, in an Ariadne document that arigl runs.
Run it →
Four viewport widgets in one window, each a view of the same scene from a camera of its own: front, side, a top-down map and a close-up. Drag in a view to turn it, the wheel zooms, a double-click puts it back. Every view draws the scene's soft shadows from the maps the main view bakes. An Ariadne document with no host code: each view is a mirror of the main renderer, drawn where its widget sits in the window.
Run it →
A plaza with buildings, a statue and people walking it, drawn four ways at once with no copy of the geometry. Each view's override: restyles the nodes it names, by id, tag or everything, as a twin actor over the node's own mapper: a wireframe on black, an X-ray where the people show through the walls, a plan of the people and their paths, and a clay model. Three of the views share one named camera, so turning one turns all three.
Run it →
Three scenes of their own in one document, each with its own lights, shadows and background, built from the same assets: the meshes are read once, and every node on them shares one copy of the geometry and its GPU buffers. Each viewport names the scene it shows. Drag a view to turn it.
Run it →
One scene, two tagged groups. The scene's main_view: picks the courtyard for the main view, and a viewport shows the gallery the main view leaves out, with shadows baked for what it draws. A map view shows both groups from above.
Run it →
A block of buildings with agents tagged sim and their goals tagged debug. The overview window is a top-down map of the buildings and agents; the layers window's view draws the tags its menu picks, through a bound state key, from its own orbiting camera.
Run it →
The Ariadne UI DSL's terminal backend (FTXUI) in the browser, behind an xterm.js terminal. It runs terminal_tour.ari, a document that renders unchanged through the ImGui backend, as a text UI. Tab and the arrow keys move between widgets, and the mouse clicks and drags sliders, window title bars and menus. F10 opens the menu bar. Ctrl-C goes to the document's on_signal handler, which asks once and quits on the second press. Single-threaded WebAssembly, so it needs no special headers.
Run it →
terminal_tour.ari again, this time through the Ariadne tvision backend: Turbo Vision (magiblot/tvision) draws the desktop, with movable, overlapping windows, a menu bar and a status line, and FTXUI lays out each window's contents. tvision runs in the browser through a console written for this page: xterm.js's keys and mouse go to its stdin and its ANSI output is drawn per frame. Drag a window by its title, F10 opens the menu, F6 moves between windows, Alt-X quits. Single-threaded WebAssembly, so it needs no special headers.
Run it →
arigl --terminal in the browser. The document's widgets run through Ariadne's terminal backend (FTXUI) in an xterm.js terminal, and its 3D scene is rendered by cvcGL into a hidden WebGL canvas, read back and drawn behind them: as iTerm2 inline images at the cells' real pixels (xterm.js's image addon), or as half-block cells. Drag the background to orbit, middle-drag to pan, the wheel zooms; Tab and the arrows move between widgets, F10 opens the menu. Switch the drawing from the page's header.
Run it →
terminal_tour.ari, the document ari runs, through arigl's terminal mode instead: the same FTXUI widgets in an xterm.js terminal, from a host that also renders a 3D scene behind them when a document has one. Tab and the arrow keys move between widgets, the mouse clicks and drags, F10 opens the menu bar, and Ctrl-C asks before it quits.
Run it →
800 vehicles cross a foggy city with no global plan — the GRL-SNAM reactive swarm on the cvc::nav runtime (no Python, no libtorch). Tune agents, fog and belief live, then Apply / Restart to watch shared belief beat private belief on the same city.
Run it →The legible cousin of the swarm: a few dozen vehicles in colour-coded convoys thread real downtown Austin to six rally points with no global plan — pure local reaction on the cvc::nav runtime (no Python, no libtorch), driven by the published trained CoefMLP. Chase-cam onto a lead vehicle, drag a rally point to re-route a whole convoy live, and under fog watch each convoy's sensed corridor light up in its own colour. Switch belief between shared, grouped and private.
Run it →
Fog of war: a vehicle detours a phantom wall its stale map shows but reality lacks, then erases it cell by cell as its sensor clears the ground. Switch between two limited-belief scenarios — ghost (a phantom wall) and dynamic (a vehicle crossing its path).
Run it →
cvc::nav's own trainer runs a short training in the page, saving a checkpoint every few steps; every checkpoint is then deployed on a walled square of city blocks it trained on, on a Jolt Humvee that stops against the buildings and on nav's kinematic bicycle that drives through them (the Plant combo switches), and you scrub through them: checkpoint k drives beside step 0, with the deployed metric against the training step, the loss curve, and the Stats and Ledger of both runs at the play head (the books against U_nav, the plant ledger). No Python, no libtorch, nothing fetched.
Run it →
The smallest scene that tests a renderer honestly: one known-good mesh on a ground plane under a StageLighting rig. Shadow-map artefacts have nowhere to hide here — acne, peter-panning and a shadow in the wrong place are all obvious on a single caster. Toggle shadows and the lighting panel to watch a tight spot cone spend its texels where a directional light would waste them.
Run it →