Thalassa

The program declares the scene once, as typed rows: entities, placements, geometry, materials, draws and a camera. Entity 11 is the pump, 12 is its valve and 13 is the keep-out zone. t.gfx.encodeScene turns the rows into one canonical scene document. A tap on the tablet and a highlight in the headset name the same valve.

chest stationScene() {
    f64[4] steel = [0.55, 0.6, 0.65, 1.0]
    f64[4] valveBlue = [0.15, 0.35, 0.9, 1.0]
    f64[4] warningRed = [0.9, 0.12, 0.1, 1.0]
    chest scene = emptyDeclaration()
    scene.entities = [t.gfx.entity(11, 0), t.gfx.entity(12, 11), t.gfx.entity(13, 0)]
    scene.transforms = [t.gfx.transform(11, at(0.0, 0.0, 0.4), null),
        t.gfx.transform(12, at(0.5, 0.0, 0.25), null),
        t.gfx.transform(13, at(0.6, 0.0, 0.6), null)]
    scene.geometries = [t.gfx.geometry(1, quad())]
    scene.materials = [t.gfx.material(11, solid(steel)),
        t.gfx.material(12, solid(valveBlue)), t.gfx.material(13, solid(warningRed))]
    chest state = drawState()
    scene.draws = [t.gfx.draw(13, 13, 1, 13, state),
        t.gfx.draw(11, 11, 1, 11, state), t.gfx.draw(12, 12, 1, 12, state)]
    scene.cameras = [planCamera()]
    text? selected = "plan"
    scene.selectedCamera = selected
    return t.gfx.encodeScene(scene)
}

Each device gets a mesh level from its screen size, and the program owns the ladder. The watch face is 396 by 484 pixels, so it takes level 3. The tablet takes level 1, and the workstation and headset take level 0. A lower rung removes triangles; it never changes the valve, its color or its ID.

# The larger screen side picks the mesh level. The ladder is policy.
i32 meshLevelFor(f64 width, f64 height) {
    f64[] minPx = [1600.0, 1000.0, 600.0, 0.0]
    i32[] levels = [0, 1, 2, 3]
    return t.media.targetMeshLevel(width, height, minPx, levels)
}

i32[] deviceLevels() {
    i32 watch = meshLevelFor(396.0, 484.0)          # 3
    i32 tablet = meshLevelFor(1280.0, 800.0)        # 1
    i32 workstation = meshLevelFor(2560.0, 1440.0)  # 0
    i32 headset = meshLevelFor(1832.0, 1920.0)      # 0
    return [watch, tablet, workstation, headset]
}

Before any frame, Thalassa runs capability admission. It reads each need from the render program itself and checks it against the backend's measured features and limits. The workstation also asks for temporal reconstruction at the 1.5x upscale rung. That request must name every resource it reads, and a missing one refuses by name.

chest temporalRequest() {
    chest config = t.recon.configNew("rtGI", 7)
    config = t.recon.declareTier(config, "temporal")
    config = t.recon.declareRatio(config, "1.5x")
    config = t.recon.declareHistorySource(config, "colorHistory")
    config = t.recon.declareDepthSources(config, "sceneDepth", "prevDepth")
    config = t.recon.declareOnResize(config, "rescale")
    config = t.recon.declareOracleReadout(config, "rmse:0.014")
    return t.recon.resolveRequest(config)
}

text admission() {
    chest resolved = temporalRequest()
    bool ok = resolved.ok
    text? reason = resolved.reason
    if (ok || reason == null) { return "admitted" }
    text named = reason
    return "refused: " + named      # "no declared velocity source"
}

Thalassa compiles the scene into a Reef render program. Every shader in it is checked Glint IR. The backends lower that IR to WGSL for WebGPU, HLSL for Direct3D 11, SPIR-V for Vulkan and MSL for Metal. The Soft renderer runs the same IR on the CPU, and each backend's pixels are compared with its pixels.

# One frame on the Soft renderer, and the digests it names.
text frameReport(chest result) {
    u32 status = result.status
    chest? maybeFacts = result.facts
    if (status != 0 || maybeFacts == null) { return "no frame" }
    chest facts = maybeFacts
    sha256 programId = facts.programDigest
    sha256 shaderId = facts.moduleDigest
    u64 generation = facts.sceneGeneration
    return "generation " + text(generation) + ", program " + text(programId) +
        ", shader " + text(shaderId)
}

text main(text[] argv) {
    chest job = t.chest.decode(t.buffer.hexDecode(argv[1]))
    return frameReport(t.render.offline.unretainedSingleFrame(job))
}

Input reaches the program the same way on every device. The host turns a key press, a tap or a controller button into one ordered, typed event per call. The program folds that event into its next state, and the next frame draws the change on all four screens.

const chest keys = {
  u32 space = 44     # USB HID usage
  u32 down = 1       # key phase
}

chest event(chest input) {
    u64 generation = input.generation
    chest S = input.state
    chest e = input.event
    text kind = e.kind
    if (kind == "inputKey") {
        u32 phase = e.phase
        u32 usage = e.usage
        u32 downPhase = keys.down
        u32 spaceKey = keys.space
        if (phase == downPhase && usage == spaceKey) {
            S.valveIsolated = true
        }
    }
    return completed(generation, S)
}