Cocytus arrives as a deterministic esolang that takes the idea of hostile computational environments and pushes them one circle deeper than Malbolge ever did. Where its predecessor made the instruction stream betray the programmer, Cocytus builds an entire machine around the premise that programs should be watched, counted, frozen, and required to prove they are what they claim to be. Version 0.2.1 is now in preparation, and it carries a self-hosted compiler fixed point that the project treats as a first-class architectural commitment rather than a party trick.

Dante's Ninth Circle, Recursively

Malbolge drew its name from Dante's eighth circle of Hell and operated on the assumption that programming had grown too comfortable. Cocytus takes the next leap. In Dante's Inferno, Cocytus is the frozen lake at the bottom of Hell, divided into four rings: Caina, Antenora, Ptolomaea, and Judecca. Those names are not decoration in this language. Each one maps directly onto a semantic mechanism of the machine.

Version 0.1 made the machine executable. Version 0.2 demanded the compiler survive its own compilation. Version 0.2.1 carries that fixed point into the compiler design itself, not by printing its own source code, not by stashing a second compiler in the host environment, and not by renaming a reconstructed image and calling the problem solved.

Exact Arithmetic and Conway Cuts

Cocytus refuses floating point entirely. Numbers live as finite dyadic values of the form x = N / 2^M, where N is an integer and M is a natural number. Every representation is normalized canonically, so 6/2^3 and 3/2^2 are the same value. Addition and multiplication stay exact within the representable domain. For addition, the machine computes k = max(m, n) and combines numerators accordingly. Multiplication simply adds the exponents in the denominator. If a result falls outside the machine's defined bounds, Cocytus does not round or approximate. It becomes unresolved.

Beyond dyadics, the language supports bounded finite, well-founded Conway cuts of the form { L | R }, where every left option is strictly less than every right option. Each cut carries a birthday function that measures its construction depth: zero for the empty cut, and one plus the maximum birthday of its options otherwise. A number in Cocytus therefore carries both a value and a construction history. The designers considered this sufficiently inconvenient, and kept it anyway.

The Four Zones

Caina commits visual state. The machine owns a deterministic 640-by-400 raster, and any committed frame must reproduce the same bytes from the same committed state. Pixels have acquired semantics because of this requirement.

Antenora transforms every ordinary input byte x through the map A(x) = (3x + 1) mod 256. Since 3 and 256 are coprime, this transformation is invertible: the inverse is A^-1(y) = 171(y - 1) mod 256. The map is a permutation across all 256 byte values, meaning it is fully reversible. The designers note that random corruption would have been easier.

Ptolomaea marks function entry and uses the machine's preserved, bounded call and return mechanism. There is no secondary imaginary stack hiding behind the first one to make the experience gentler.

Judecca is where memory freezes. The instruction judecca ADDRESS COUNT declares a permitted access budget for a given address. Access 1 is permitted. Access 2 is permitted. After N accesses, the address freezes. Access N+1 faults. The frozen location becomes permanently immutable. Mutable memory in Cocytus is not merely finite in size but finite in patience, and the programmer must know how many times a program is allowed to read a location before it locks forever.

The Machine and Its Trust Chain

Cocytus source files use the .coc extension, and every instruction is a fixed 48-byte form. The numeric core consists of exact finite dyadics and finite well-founded Conway cuts. Execution is deterministic, bounded by stack, variables, memory, comparisons, branches, calls, returns, raster operations, and explicit visual commits. The presentation layer is the deterministic 640-by-400 raster, and the trust seed is a single visible C bootstrap file. The C file is the beginning of the trust chain, not a disguised end to it.

The Compiler Fixed Point

The self-hosting story is where Cocytus distinguishes itself from conventional compiler projects. Let C0 be the visible C trust seed and S be the native Cocytus compiler source written in .coc. Define C1 = C0(S), C2 = C1(S), and C3 = C2(S). A self-hosted compiler image is a fixed point when Phi(C*) = C*. Cocytus requires three consecutive compiler images to be byte-for-byte identical: bytes(C1) = bytes(C2) = bytes(C3). All three images share the SHA-256 hash 56dfe31a0e0cbc73fd46dd484e970af820fc0ce0b91ad9a73f99a2c59d855bc6.

This is not a quine. A conventional quine establishes that P maps to text(P), proving a program can reproduce a representation of itself. That is amusing. Cocytus requires the compiler source S to be compiled into an executable image, then passed through that same compiler until the executable itself stops changing. The visible C seed remains the runtime host boundary: the richer VM, the Conway engine, graphics, and host integration all live inside that single C file, while the canonical compiler core is the component proven at the self-hosted fixed point.

What It Means for Developers

Cocytus does not ask developers to write practical software. It asks them to think about what a programming language owes to its own reproducibility. The finite-access memory model forces a kind of resource awareness that most languages delegate to garbage collectors or manual management. The exact arithmetic removes an entire class of floating point bugs at the cost of requiring the programmer to think in dyadic rationals. The deterministic raster means every pixel is a commitment, not an accident. And the compiler fixed point means the language's core is proven not by a marketing slide but by three byte-identical artifacts.

Malbolge occupied the eighth circle of Dante's Hell. Cocytus takes the ninth, and it freezes the lake. Version 0.2.1 ensures the compiler has already been made to survive itself, so at least one thing in this frozen lake is permanent. The project is released under the Apache License 2.0, which is not the public domain. Even Hell has paperwork.