As of October 30, 2026. This dossier describes blob.in 0.1.0, the public projection at commit 4278b06. Underlined links lead to the files of that commit, frozen.
Dossier · The native surface
blob.in — a surface that invents no pixel
The surface computes no geometry: every pixel of the view comes from a frame received from the engine, through a strict contract. When something fails, it shows it; it never replaces it.
On this page
In one picture
Think of a projectionist. They project the reel they are given, without retouching it. If a frame arrives burnt, they show it burnt and note it in the log; they do not swap in a frame of their own so the audience sees nothing.
blob.in is that projectionist. An engine computes shapes; the surface puts them on screen, checks every frame it receives, and says out loud what is wrong.
What the surface does
blob.in is a native desktop application, written in Rust, for Wayland (Hyprland). It shows soft shapes: circles that join, subtract, blend into rounded unions. The engine describes them as a signed distance field — for every point, the distance to the shape's edge — and draws a frame from it.
The window offers six "labs" (primitives, Boolean operations, smooth union, field, normals, material), four ways to view the same computation (distance, normals, coverage, lighting) and a choice of compute engine: CPU, CUDA or Vulkan. You drag a circle with the mouse, change its radius with the wheel, add or remove a shape.
CUDA05F_GATE_PASS shown verbatim at the top left. "Lit" mode is shading computed from the normals, in 2D: it is not a 3D render. Source: run.json.The Diagnostics panel shows the real data of the session and of the frame on screen: the requested and the actual engine, the qualification copied verbatim, the dimensions, the measured round trip. No metric is invented: a field that was not measured is not shown.
The BLOB-FRAME-v1 contract
The engine and the surface are two programs. They talk over a local Unix socket; each frame travels in a region of shared memory (a memfd) that the engine seals before handing it over: once sealed, nobody can change it.
Before displaying, the surface checks the requested size, the exact stride between two rows of pixels, the format, the geometry fingerprint, the scene revision, the request number, and that the actual engine is the one requested. If a single point fails, the frame is refused, and the reason is shown.
"No fallback: a failure of the requested backend is shown, never replaced," the interface itself says. If you ask for CUDA and the card refuses, the surface does not quietly switch to the CPU: it says so. See crates/blob-frame.
Nineteen faults, provoked on purpose
To check that it refuses what it must refuse, the surface has its own isolated test server, which can provoke nineteen faults on demand. A "TEST SERVER" banner stays on screen while it is connected: its test patterns are never presented as engine frames.
| Family | Provoked faults |
|---|---|
| The engine goes silent | render error, timeout, connection closed, no answer |
| The frame lies about itself | wrong size, truncated frame, unsealed memory, padded rows, unexpected format, malformed fingerprint |
| The engine cheats | another engine than the one requested (the silent fallback), wrong revision, answer to another request |
| The message breaks the contract | unknown field, two memory regions attached, none attached, oversized message, unreadable message, wrong protocol version |
Source: blob-frame-testserver.
What is proven, and within what frame
The public version was built on its own, from its own content alone: 225 tests pass. Two are set aside by default, because they read engine frames kept outside the repository.
The end-to-end runs open a real window under Hyprland, resize it to four sizes, and capture only the window's rectangle each time. They ran with all three engines. A scripted exercise chains fourteen gestures — moving a circle, changing a radius, switching operation, view, engine — and checks at each step that the frame follows.
The same runs measure the round trip between a gesture and the displayed frame: 14 to 35 ms on the CPU, 289 to 379 ms on Vulkan, 470 to 670 ms on CUDA. Speed is not what this surface is about, and no frame rate is claimed.
Since then, the repository has started drawing its own interface without an off-the-shelf toolkit: controls, strokes, Bézier curves, polygons with holes, gestures. Each step carries a report and a bounded verdict ("scoped pass"), qualified headless or in an isolated compositor.
History
| Date | What happens |
|---|---|
| October 10, 2026 | The client side of the BLOB-FRAME-v1 contract and the test server arrive; the same day, the first end-to-end runs with the real engine, on all three compute engines (30 commits). |
| October 12 | The busiest day (39 commits): the native interface begins — controls, strokes, fills — and gestures are qualified in an isolated compositor. |
| October 13–14 | Scrolling and hover, axis lock for drags, list cursor. |
| October 30 | First public version, 0.1.0, under the MIT licence: a single commit, cut from the private repository by a tool, built and tested on its own before being pushed. |
What it is not
- Not the engine. The engine that computes the shapes is not published yet; without it, the public version runs with the test server and its patterns.
- Not fast, not yet. No 60-frames-per-second rate is qualified; measured round trips go up to 670 ms.
- Not a 3D render. The lighting is 2D shading computed from the normals.
- Not yet tried with the real pointer. Gestures are qualified headless and in an isolated compositor; the test with a real mouse in the session remains open.
What it changes, depending on who you are
Developer
A complete example of a boundary between two processes: sealed shared memory, a contract checked field by field, and a fault server to prove it.
Quality lead
Every refusal has its test, every capture its fingerprint, and the surface never passes a test frame off as a real one.
Decision-maker
Software that says when it fails rather than pretending: the condition for trusting it with a machine.
Going further
- The repository: gnu6dotlive/blob.in.
- The licence decision and what is not published: LICENCE-DECISION-20261030.md.
- The native rendering research, on the scene engine side: the in.gnu6 dossier.