Cartilage 2026: Child-Owned Reconfiguration Ports

June 30, 2026

A reconfiguration port can belong to the child region that it creates.

Cartilage 2026 makes that ownership visible inside a running WebGL/GPGPU fabric. Active port roots sit beside square 6x6 child regions, while ordinary parent pointers preserve each region’s coherent local tree.

A 450-frame native-pixel capture follows the renderer through initialization and fill. The standalone WebGL machine, source record, hashes, timing calculation, and boot-state decoder travel with it.

Watch Child-Owned Regions Appear

Cartilage 2026 WebGL fabric showing active child-owned reconfiguration port roots and square ownership blocks
The running WebGL/GPGPU fabric across 450 frames. This native top-left 512x1024 crop comes directly from the full 1024x2048 render.

Run the Cartilage 2026 WebGL fabric

Open Every Part Of The Run

The complete packet joins the machine, 450-frame capture, technical README, and decoded boot-state report:

Source and capture hashes connect the files to the same run, while the timing calculation explains why a complete 252-bit image fills within the 450 recorded frames.

Cartilage Core distills this architecture into a compact WebGL1 machine and a matching local-clocked SystemVerilog implementation. Its public source repository adds the hardware paper, self-checking Verilator testbench, and an exact 6x6 AND installation.

Both implementations descend from cartilage26/cartilage3.html at revision 4143b8a; this page preserves the large visual field, while Cartilage Core isolates the mechanism for hardware development.

The Port Belongs To The Region It Creates

Each reconfiguration port serves as the root of its child subtree. The port’s parent direction selects the external application ingress side, while ordinary parent pointers organize the rest of the square child region.

Separating port role from ownership lets the port move without collapsing the initialized region. Role column, ownership tree, and active configuration signal cooperate as distinct parts of the architecture.

The Field At Native Resolution

The visible fabric is a 32x64 logical-cell WebGL/GPGPU renderer. Each logical cell uses two RGBA texels of state. The full native render is 1024x2048; the GIF is the native top-left 512x1024 crop.

The initialized reconfiguration corridor runs beside preallocated square blocks. The corrected boot shape assigns all 36 parent pointers in each 6x6 region, so the visible ownership structure fills the complete square from its port root.

The First Frame Determines The Tree

Moving the port and wire columns also required a complete square ownership tree. Boot initialization now writes all 36 parent pointers for every 6x6 subtree.

A second startup interaction exposed the decisive detail. When a shifted root began with an inactive conf_signal, the engine’s parent-rotation fallback could rotate nearby child pointers during the first compute steps.

Initializing each shifted root with conf_signal: 1.0 keeps the child-owned square active from the first frame and preserves its intended geometry.

A 252-Bit Transaction Fills In 420 Frames

A complete 6x6 region contains 36 cell records. Each record carries seven bits: two orientation bits, three mode bits, and two parent-direction bits.

36 cells * 7 bits = 252 bits

The current renderer advances COMPUTE_STEPS = 30 updates per rendered frame. The internal configuration clock toggles every 25 GPGPU updates, so one complete clock cycle is 50 updates.

252 * 50 / 30 = 420 rendered frames

The 450-frame capture shows the complete fill plus 30 frames of the resulting state.

The 36-Cell Image Holds Together

Static checks find every slot 0..35 exactly once, count 36 records in both ownership templates, measure the active bitstream at 252 bits, and confirm the corrected root construction.

A byte-level decoder reads the initialized first 6x6 block and matches the expected parent-direction grid. It also finds active conf_signal bits in all 36 cells, connecting the source-level image to the visible first frame.

That complete boot state provides the starting point for readout, repeated dynamic installation, and coarser multi-region fabrics.

Read The Roles, Then Follow The Region

Cartilage Visual Language decodes the 32 body roles: reconfiguration port, cross, constants, wire orientations, and MUX modes.

Runtime Instantiation In Adjacent Space develops the parent-and-daughter region model. This 2026 machine shows how child-owned port roots preserve that relationship across a large visible field.

Three Fields Make Ownership Legible

The role column says what a cell does. The parent pointer says which local tree owns it. The active configuration wire says when that tree receives a new image. Keeping those fields distinct lets the render explain how one region can create another without surrendering its own structure.

Try Cartilage: Run the open one-slot multiplier.

To edit, load, save, share, and follow the browser, Raspberry Pi, and FPGA streaming work, request the private demo username and password on LinkedIn.