The answer is less important than the fact that the computation passes through a readable body.

This package documents a real browser-fabric computation: a 64x64 Cartilage GLSL fabric seeded with a generated 3-bit ripple-carry adder body, driven by one external input frame for a = 6 and b = 5, then advanced for 256 committed update cycles.

The output ports read s0 = 1, s1 = 1, s2 = 0, and s3 = 1. In the adder's little-endian output order that is 1101; in ordinary most-significant-bit display order it is 1011, decimal 11.

Measured compute runThis page is part of the Cartilage Run and Sketch Index.

Included: 6 + 5 = 11, a 64x64 fabric, 256 update cycles, 257 captured committed states, QFG source, manifests, videos, run reports, and boundary I/O decode.

Run focus: a measured compute pass through a pre-generated adder body, with visible input lanes, output lanes, and expected sum/carry behavior.

The Compute Claim

The driver does not compute the arithmetic answer. It seeds the browser fabric with primitive Cartilage cell bodies, stages sparse boundary-metal writes for one QFG frame, advances the fabric, and reads the external edge surface.

The measured run is not the 525,568-cycle native reconfiguration run. The adder body is installed as the initial QFG seed before the measured compute run begins. The claim here is narrower and easier to read: an existing Cartilage body receives input bits at its boundary and computes the visible result through its cell state.

Callout Video

The preferred publication video: 257 contiguous committed states, with sparse callouts for operand inputs, sum stages, carry-out, and result ports.

Open the callout GIF preview

Final State

Final callout-rendered Cartilage state for the 6 plus 5 computation, labeling input A, input B, sum stages, carry out, and s0 through s3 result ports — The final committed state labels `INPUT_A=6`, `INPUT_B=5`, `BIT1_SUM_STAGE`, `BIT2_SUM_STAGE`, `CARRY_OUT`, and the four result ports.

The Artifact Bundle

The files are preserved under cartilage/codex5.5/. These links point to concrete files, not directory listings.

quadflow-use-static3-a6-b5-fullframes.md - package note and reproduction commands.
use-static3-a6-b5.qfg - exact QFG source streamed into the browser fabric.
use-static3-a6-b5-callouts.surface.qfg - sparse publication callout labels.
use-static3-a6-b5-run-report.md - raw lockstep run report for the coordinate render.
use-static3-a6-b5-callouts-run-report.md - raw lockstep run report for the callout render.
quadflow-use-static3-a6-b5-fullframes-manifest.json - frame list, hashes, and verification metadata for the plain render.
quadflow-use-static3-a6-b5-fullframes-callouts-manifest.json - frame list, hashes, and verification metadata for the callout render.

Frame Coverage

The computation ran for 256 fabric update cycles. The capture contains 257 PNGs because it includes cycle 0, then every committed state after cycles 1 through 256. The MP4 frame count was verified as 257 frames at 512x512 and 30 fps.

Representative direct frame links:

The manifests contain the complete 257-frame lists and SHA-256 hashes for both frame sequences.

Boundary Inputs

The generated QFG contains 469 seed cells and one operand frame. It contains no embedded expect lines. That matters because the result is read back from the external edge surface, not from expected-output clauses inside the input stream.

The high-level frame comment in the QFG source is:

# a=6 b=5 -> 1101
frame 256
boundary left 7 gnd parent left
boundary left 13 gnd parent left
boundary left 3 pwr parent left
boundary right 8 pwr parent right
boundary left 11 pwr parent left
boundary left 23 pwr parent left
boundary left 27 pwr parent left
boundary left 17 gnd parent left
boundary left 22 gnd parent left
boundary left 25 gnd parent left
boundary left 41 pwr parent left
boundary left 45 pwr parent left
boundary left 35 pwr parent left
boundary left 40 pwr parent left
boundary left 43 pwr parent left

For a = 6, the operand bits are a0=0, a1=1, a2=1. For b = 5, they are b0=1, b1=0, b2=1. Those become the pwr and gnd boundary lines in the QFG frame.

Output Readout

The run report says the final active boundary outputs were at left edge position 8, right edge position 16, and right edge position 48. The documented output decode is:

left[8]       -> s0 = 1
right.sl[16]  -> s1 = 1
right.sl[34]  -> s2 = 0
right.sl[48]  -> s3 = 1

So the emitted result order is s0 s1 s2 s3 = 1101. Interpreted in ordinary display order, that is 1011, decimal 11.

Callouts Are Not Computation

The callout layer is drawn after the fabric state is rendered. It labels input regions, output ports, and core adder regions for explanation. It does not alter any cell, edge, Sinew metal, Intersin value, QFG frame, or result bit.

mark 0 23 INPUT_A=6
mark 0 3 INPUT_B=5
mark 15 12 BIT1_SUM_STAGE
mark 25 30 BIT2_SUM_STAGE
mark 25 44 CARRY_OUT
mark 0 8 s0=1
mark 63 16 s1=1
mark 63 34 s2=0
mark 63 48 s3=1

Run Boundary

This is still a small computation, and the adder body is pre-generated before the measured run starts. The useful part is that the source QFG, boundary frame, run report, manifests, first and final frames, videos, and every committed PNG state are all part of the published artifact package.

Cartilage Visual Language

The 32 Cartilage cell-role codes are a compact body-type alphabet: reconfiguration port, cross, constants, four wire orientations, and six MUX modes in four orientations. The Cartilage Visual Language article shows the rendered key and decodes all 32 codes.

Current Core Reference

Cartilage Core and the public source repository are the current compact mechanism and hardware reference. They are not the source tree for this older QuadFlow/QFG run; the bundle above remains authoritative for the stated 6 + 5 = 11 result.

Readout Boundary

The boundary writes, callout labels, output readout, and manifest hashes should all line up with the stated 6 + 5 = 11 result.