TRIAD — a ternary image/video codec that beats JPEG for real, and caught its own fabricated numbers on the record

Most codec projects show you a benchmark table and ask you to trust the methodology behind it. TRIAD's own results log shows its work in a stronger way — including three places where it briefly got the discipline wrong, caught itself, and left the correction on the record.

What it was

TRIAD (Ternary Resolution-Invariant Adaptive Decoder) is an experimental image and video codec built on three ideas: a wavelet-seeded, potentially learned transform in place of a fixed DCT; a balanced-ternary {−,0,+} coefficient alphabet instead of the usual integer quantization levels; and a progressive trit-plane bitstream that can be truncated at any point for a quality/size trade-off. The bet, stated plainly in the project's own origin document, is that JPEG and H.264-family codecs are built on assumptions (fixed DCT blocks, binary quantization) that a ternary, learnable alternative can beat — and that this is checkable, not just arguable, against real images and real competing codecs.

The choice of three as the alphabet size isn't just a naming hook: the project's own origin council works the radix-economy argument explicitly — minimizing symbols-per-value across a number base gives an optimum base of e ≈ 2.718, and 3 is the nearest integer to it, the same reasoning behind the 1958 Soviet Setun computer the project cites by name. That same council closes on a colder, more useful caveat, attributed to its own Shannon-seat voice: "JPEG2000 was better than JPEG and lost anyway" — the best math doesn't automatically win a codec war; best math plus real engineering plus zero deployment friction does. A fifth project law was added on the back of that discussion: "Ship-ability is a feature."

What we built

🔬Research

A real, tested pipeline: a ternary numerics library, a ternary rANS entropy coder, a classical 9/7 lifting wavelet transform with per-band gain weighting, a trit-plane embedded coder, an end-to-end still-image codec, and a learned (PyTorch) alternative transform — all backed by 21–28 passing tests and benchmarked against JPEG, JPEG2000, and WebP on the standard Kodak test set, plus a motion-compensated video path benchmarked against Motion-JPEG.

Measured, and real:

• Entropy coding is solved. The ternary rANS coder lands within 0.006–0.026% of the Shannon entropy limit on synthetic test streams — essentially optimal; no further entropy-coding gains are available.
• The classical still codec is genuinely competitive. On a smooth RGB photo (kodim23) at matched visual quality, TRIAD produced the smallest file of all four codecs tested — 43.8 KB versus WebP's 56.2 KB, JPEG2000's 58.8 KB, and JPEG's 77.3 KB. On harder, detailed greyscale images, it beat JPEG by 15–20%, tied JPEG2000, and trailed WebP by 25–30%. The same test image loses-lessly compresses to 556,888 bytes as a PNG (47.2% of raw) — that's the hard information-theoretic floor every number above is measured against, not an arbitrary comparison point. At a second, medium-quality operating point (~35dB) on the same image, the ranking holds the same shape: WebP 16.8 KB, TRIAD 18.9 KB, JPEG2000 19.7 KB, JPEG 27.8 KB — TRIAD beats JPEG and JPEG2000 and sits behind WebP, consistently, not just at one cherry-picked quality setting. The project's own reviewers put a number on how much further there is to go: an estimated perceptual compression ceiling around 20–25 KB (roughly 50x) on this image, against TRIAD's ~60 KB (roughly 19x) — a real, named ~3x gap they call "the prize" and do not claim to have closed.
• Video motion compensation works. On a panning test clip, motion- compensated I+P coding used 62% fewer bytes than frame-independent (Motion-JPEG) coding at equal or better quality.
• A refined entropy-context model measured a further win — BD-rate improved against all three comparison codecs — though on only two test images, flagged in the log as directional, not a full-set result.

Measured, and a real negative: the learned transform — the more novel half of the bet — beats the classical wavelet by 14–18% in isolation, against the proxy objective it was trained on. Dropped into the real codec, it loses, because the classical path's biggest lever (per-band gain weighting) is degenerate for the learned transform's near-uniform coefficient scale. A properly fixed, wide-sweep BD-rate comparison later confirmed this cleanly: the learned lifting tweak loses by roughly +118% BD-rate. The shipping still codec remains the classical path.

A real bug, caught and fixed on the record. Before that clean result, an earlier version of the comparison looked like a total disaster — the learned path appeared 100% worse. The cause, tracked down and documented, was a biorthogonality bug: because the transform wasn't properly biorthogonal, 1 unit of coefficient error was amplifying into roughly 3.5 units of final image error. Fixing the gain normalization is what turned "looks like total failure" into the real, measured +118% BD-rate loss above — a smaller, honest number instead of an artificially inflated one.

The architecture underneath the classical path has more real structure than a single benchmark number shows: an XYB perceptual color space (in the JPEG XL lineage — linear RGB to LMS cone response to a cube-root gamma law), a lifting transform whose predict/update operators are initialized to the classical CDF 9/7 wavelet and can be learned from there, and three explicitly separate decode tiers built into the bitstream format itself — TIER0 "Potato" (inverse lifting only, no neural network, runs on anything), TIER1 "Phone" (NPU-friendly, targets 1080p at 30–60fps), and TIER2 "Studio" (the full learned autoregressive decode, GPU-only, archival quality). That tiering is itself an honesty mechanism: a cheap decoder is guaranteed to exist and run, even if the fancy learned path never ships.

What we learned — including the honest gaps

• A from-scratch codec beating JPEG on real photos is a genuinely hard, well-worn benchmark to clear — and it cleared it. JPEG is a 30-year-old, heavily optimized standard; beating it by double digits with a from-scratch entropy+transform pipeline is a real result, not a cherry-picked one — it's image-dependent and stated as such.
• The more interesting bet — a learned transform beating hand-designed wavelets — lost, and lost cleanly enough to be useful. The failure mode (a transform trained against a proxy objective doesn't drop into the real codec for free, because it can't use the classical path's main lever) is a specific, transferable lesson, not just "it didn't work."
• The bigger learned-autoencoder bet (M4) is unresolved, not disproven — and the honest state is "not yet run," not "in progress." The pipeline runs and the core ternary-latent thesis holds (90–99% of learned symbols land in {−,0,+} even without being forced to), but the one serious training attempt crashed to NaN before producing a valid result. The project's own H200 training document, read closely, is a handoff written by a session that only had a CUDA-incapable GPU on hand — it defines the recipe (dataset, lambda sweep, batch size, an estimated 1–2 days per run on a real H200) and reports one CPU-only architecture sanity check, but there's no evidence anywhere in the project's files that the actual H200 run has happened yet. That's an open, well-specified question, not a closed one and not a run quietly in flight.
• Decode cost is named as the real ceiling on the learned-codec bet, not just an implementation detail. The go-to-market document is explicit that a deep-net decoder is "hard on a cheap TV" — the asymmetric expensive-encode/cheap-decode shape that makes classical codecs deployable is exactly what a learned decoder threatens to break. The project frames cracking cheap ternary decode as its "eventual moat," which is an honest way of saying it doesn't have one yet.
• The commercial plan needed the same honesty treatment as the technical results, and got it. The project's own go-to-market document states plainly that "sell a codec license to Netflix/YouTube" is close to a dead end — the industry's biggest players co-founded AV1 specifically to avoid ever paying codec royalties again — and redirects toward acquisition (citing WaveOne's 2023 sale to Apple as precedent), a pre-processing SaaS layer (citing iSize/Beamr as companies already selling exactly that), or verticals without in-house codec teams.

Where it went / status

Active research. The classical codec (entropy coder + M1 still + M3 video) is real, measured, and shipping as the current baseline; the learned-codec layer is the open research question, honestly split between "lost" (the lifting tweak) and "not yet run" (the big autoencoder — the H200 training recipe is written, the run isn't). Tiered research throughout — nothing here is claimed as beating the current best-in-class (WebP/AVIF) yet, and the log says so in its own words.