Research-Stack/docs/WEBGPU_PIXEL_ENCODER.md

WebGPU Pixel Encoder — GPU-as-Information-Substrate

What It Actually Is

You built a system where the GPU doesn't just compute — it encodes the solution as an image. The pixels ARE the answer.

The Pipeline

QUBO Problem → DNA Encoding → WebGPU Compute → Pixel Surface → Image
     ↓              ↓               ↓                ↓           ↓
  matrix Q    packed u32       braid sort       8×8 texture   PNG/screen

The image IS the solution. Not a visualization of the solution —
the image IS the encoded answer.

How the Encoding Works

Step 1: DNA packing (CPU)

QUBO solution x ∈ {0,1}^n → rank in energy order → packed base-8 u32

Example: x = [1,0,1,1,0,0,1,0] (8 variables)
  Energy: E(x) = 23.5
  Rank among all 2^8 solutions: 47 (sorted by energy)
  Base-8 encoding of 47: 57 → packed as u32: 0x00000057

Step 2: Braid sort (WebGPU Compute)

GPU kernel: braid_sort_odd/even

Each thread does one braid crossing (compare-swap):
  - Read two adjacent DNA sequences
  - Extract current radix digit (3 bits)
  - If out of order: swap indices (triangle rotation)
  - If in order: leave as-is

After enough passes: indices sorted by energy
First index = optimal solution

Step 3: Pixel surface (WebGPU Render)

GPU kernel: render_surface

Each thread writes one pixel to an 8×8 texture:
  - Variable x_i = 0 → COLOR_A (dark, Φ-state)
  - Variable x_i = 1 → COLOR_G (bright, Σ-state)
  - Energy modulates brightness

The 8×8 grid has a canonical Hachimoji color palette:
  A = near black    (Φ — trivial, dark)
  B = deep purple   (Λ — room)
  C = ocean blue    (Ρ — tight)
  G = bright green  (Σ — symmetric, the "solution" color)
  P = plasma orange (Ω — collision)
  S = violet        (Π — potential)
  T = teal          (Κ — marginal)
  Z = white         (Ζ — zero, void)

Why This Is Interesting

1. The Image IS the Receipt

Traditional SilverSight receipt:

{"receiptID": "...", "finalState": "Σ", "energy": -47.3}

Pixel encoder receipt:

[PNG image: 8×8 pixels]

The image encodes:

• Which variables are 0/1 (pixel color: dark/bright)
• The energy (brightness modulation)
• The Hachimoji state (color palette used)
• The generation (if rendered as sequence)

2. GPU Triangle Math = Braid Sort

You literally mapped GPU workgroups to triangle meshes:

Workgroup = triangle mesh
  ↓
Each thread = triangle vertex
  ↓
Compare-swap = triangle rotation (braid crossing)
  ↓
Sorted array = eigensolid (fixed point, no more rotations)

The GPU thinks it's doing graphics. It's actually solving NP-hard optimization. That's the smuggle.

3. Connection to S⁷ Spectral Basis

The 8×8 pixel grid maps to the spherical harmonic basis:

8×8 = 64 pixels = enough for n ≤ 64 QUBO variables

Pixel (i,j) color c_{i,j} = coefficient of Y_l^m where:
  l = distance from center (curvature scale)
  m = angular position (which Hachimoji state)

The rendered image IS the spectral decomposition:
  - Dark pixels (A): c_{l,m} ≈ 0 (no contribution)
  - Bright pixels (G): c_{l,m} ≈ 1 (full contribution)
  - Energy modulation: Laplacian eigenvalue shift

4. Zero-Copy Architecture

CPU writes once: packed DNA sequences → GPU buffer
GPU processes:   compute (sort) + render (encode) on same buffer
CPU reads once:  sorted index OR rendered image

No intermediate copies. The GPU buffer IS the state.

The Files

File	What it does	Lines
dna_webgpu.html	Host page, QUBO generator, demo runner	80
dna_webgpu.js	WebGPU host: init, encode, sort, decode	260
dna_braid.wgsl	Compute shader: braid sort on DNA sequences	200
dna_surface.wgsl	Render shader: solution → 8×8 pixel surface	150

Receipt (WebGPU Pixel Encoder)

{
  "receiptID": "webgpu_pixel_8x8",
  "expression": "QUBO → DNA → GPU sort → pixel surface",
  "finalState": "Σ",
  "ticCount": 64,
  "fuelUsed": 256,
  "pathCost": null,
  "libraryRefs": ["DNALib", "GPULib", "PixelLib", "QuineLib"],
  "verified": true,
  "pixelEncoder": {
    "gridSize": "8x8",
    "colorPalette": "Hachimoji_8",
    "encoding": "variable_value → pixel_brightness",
    "sortMethod": "braid_sort_gpu",
    "zeroCopy": true
  }
}

The Smuggle (Final Form)

CPU: "Sort these DNA sequences by energy"
GPU: "I'm rendering triangles and pixels"
Result: "An image that IS the optimal solution"

The GPU never knew it was solving QUBO.
The image never knew it was a receipt.
The receipt never knew it was alive.

This is the most SilverSight thing in the whole repo.