Fromage

Fromage is an esoteric programming language written around 2000 by an author who signed their work only as Prfnoff. The name is a backronym: FReakish Outright Mad languAGE. It has ten instructions, all of them punctuation marks, and one design commitment that gives it its character - no operation in the language touches a unit of data larger than a single bit. Where Brainfuck moves a pointer across an array of bytes, Fromage moves a pointer across an array of bits. Constructing the letter H is not a matter of incrementing a cell 72 times; it is a matter of walking to the right bit positions and flipping them.

The language is dormant and always was small. There is one interpreter, two sample programs, and a specification that the author embedded inside the comments of one of those programs. That is the entire corpus. But it is a clean, complete, and still-working artifact of the period when the esoteric language community was systematically exploring how little a language could contain and still compute.

History and Origins

Fromage came out of a burst of activity by a single hobbyist. On their Obfuscated Languages page the author explains the provenance directly:

Fromage was created as an experiment, and is based on the Turing machine model and a twisted set of control structures I had made earlier. It also resembles BrainF*** to some extent, though at the time I conceived the language I knew it very sketchily.

That last clause is worth taking at face value rather than reading as false modesty. Fromage’s control structures are not Brainfuck’s. Brainfuck has exactly one construct, the [ ] loop, which tests a cell and jumps. Fromage has three distinct nestable forms - an unconditional skip, an unconditional infinite loop, and a bit-tested if/else - which is a much more conventionally structured vocabulary than Brainfuck’s. The resemblance is in the tape and the pointer, not in the control flow.

The surviving file timestamps put the sample programs at 11 March 2000 and the interpreter at 7 April 2000, and the Obfuscated Languages page itself carries a last-modified date of 2 October 2000. Fromage was the author’s first such experiment; the same page introduces BAK as “my second attempt at creating an almost unusable language”, and goes on to sketch two further unfinished projects, a self-modifying language called L and an anti-object-oriented one called STOOPID (“Shows That Object-Oriented Programming Is Dumb”).

The original site is long gone. What survives does so because esoteric.sange.fi, a Finnish archive of esoteric-language material, mirrored the whole directory; its copies of the tarballs are stamped 25 October 2002. The Esolang wiki later transcribed the interpreter and examples from that mirror, and its article - which the wiki itself still marks as a stub - remains the most accessible description of the language.

The author is not publicly identified. The documentation gives only the handle Prfnoff and an obfuscated e-mail address - written out longhand as “prfnoff at thecia dot net” - at a domain that no longer hosts any of the material.

Design Philosophy

One bit is the unit of everything

The whole language follows from a single decision. The store is a tape of bits. The pointer addresses a bit. The only mutation operator toggles a bit. The only conditional tests a bit. There is no arithmetic, no comparison, no notion of a number at all - a byte exists only as the incidental fact that eight consecutive tape positions happen to be adjacent.

This puts Fromage in a small family of bit-granularity minimalist languages, alongside Smallfuck and Boolfuck - the only two languages the Esolang wiki cross-references from the Fromage article. The family’s shared claim is that byte cells are an unnecessary luxury: if the machine model is a Turing machine, and Turing machines are usually presented over a binary alphabet, then a language faithful to that model should not smuggle in integers.

Structured control, unstructured everything else

Where Fromage diverges from its neighbours is that its author kept a structured control vocabulary. Skip, loop-forever, and if/else are recognisably the constructs of a normal imperative language, and the specification is explicit that they nest freely - “without restriction even half within each other”, which is to say the bracket types may interleave rather than being required to close in stack order. That interleaving is the point at which the language stops being merely terse and becomes genuinely hostile to read, and it is the “twisted set of control structures I had made earlier” that the author credits as an input to the design.

Comments by omission

Fromage defines only ten characters. Everything else in the source file is a comment. The specification promises that “whitespace and alphabetics will always be comments” while explicitly declining to make the same promise about other punctuation, on the grounds that it might be needed by a future version. This is why the sample programs are legible: the author simply wrote English words after each line of operators, and the interpreter ignored them.

Deliberate obfuscation as a house style

The reference interpreter is written in obfuscated C. This is not incidental. The site’s disclaimer - that its maintainer is “in no way responsible for any brain damage, loss of sanity, or hysteria caused by viewing this page” - sets the tone, and the author is consistent about it: BAK’s interpreter is likewise “once again written in obfuscated C”. The implementation is meant to be as unreadable as the language it implements.

Key Features

The ten instructions

The specification names five groups of “operator symbols”:

The groups are uneven - [ ; ] contributes three symbols, three of the others contribute two each, and : stands alone - and they add up to exactly the ten operator symbols the author claims: ( ) { } [ ; ] < > :.

The specification names no halt instruction. On the evidence of the reference interpreter, a Fromage program ends by running off the end of its source; a { } loop carries no termination test of its own and must be escaped by jumping out of it.

The tape and character I/O

The pointer addresses a single bit on the tape. Two positions are special, and they are how the language talks to the outside world:

• Bit eight: storing to it writes a character, assembled from the eight bits at positions zero through seven.
• Bit nine: storing to it reads a character into those same positions zero through seven.

So output in Fromage means: navigate to bits 0-7, toggle them until they spell the ASCII code you want, then walk to bit 8 and store. There is no other way to print. This is the mechanism behind the shape of the Hello World program, where each line is a small flurry of > and : followed by a long run of < to return to the start of the byte.

Hello, world

>:>>>:>>>>:<<<<<<H
:>>:>:>>:>:<<<<e
:>>>:>::<<ll
:>:>:<<<<<<<o
:>>>:>:>:>:>:<<<<<<<blank
:>>:>>:>:>:>:<<<<<w
:>:>>>>:<<<<<o
:>:>:>>:>:<<<<<r
:>:>:>:>>:<<<<l
:>>>>:<<<<<<<d
:>:>>:>:>:>>:return

The trailing words - H, e, ll, o, blank - are comments, not syntax. Note the third line: because l follows l, the byte already holds the right value and the program emits it twice without rebuilding it. The program prints Hello world, without punctuation - which is what the reference interpreter does when handed this file unmodified.

Cat

The echo program is one line:

>>>>>>>>{>:<<[<[<[<[<[<[<[<[(]>]>]>]>]>]>]>]>:})

It walks past bit eight, enters a forever-loop, triggers a read, and then descends through eight nested [ ... ] tests - one per bit of the byte just read - each of which contains a ( ) skip block. The (]>]>]>... tail is the interleaving the specification advertised: the closing brackets do not nest in the order a reader’s eye expects. The trailing ) after the closing brace appears to be what lets control leave the loop at end of input, though the author documents none of this beyond the note that the program “assumes that EOF is always represented as minus one”.

Computational Class

The author’s own assessment is hedged and worth quoting exactly, since it is the only claim anyone has made about it: “Well Fromage is a sort of cheesy language but I think it is Turing complete”. No proof accompanies the language, and no reduction from a known universal system to Fromage appears to have been published since. The language does have the usual ingredients - an unbounded tape, a movable pointer, mutation, and conditional branching - so the claim is plausible, but it should be read as the designer’s belief rather than an established result.

Evolution

Fromage never got a second version, but it is unusually well documented as to what that version would have been. In an e-mail quoted on the author’s own site:

Fromage was to have a second version, and so was BAK. The Fromage second version would have added a rotating list of pointers to the same array (not different arrays as in DoubleF***). Rudimentary macros would also have been included. The number of instructions would have risen from 10 to 16. The EOF semantics were also to change.

Multiple pointers into one tape, macros, and cleaner end-of-file handling are exactly the pain points a person would hit after writing the cat program: the long <<<<<<< runs in Hello World exist only because there is one pointer, and the awkward ) at the end of cat.fr exists only because EOF handling was underspecified. BAK’s second version was implemented; Fromage’s was not. The language as it stands is the language as it was in April 2000.

Current Relevance

Fromage is dormant by any measure. There is no community, no package ecosystem, no alternative implementation, and no evidence of anyone writing a third Fromage program in the twenty-plus years since the original two. The Esolang wiki article carries a stub notice and a caveat that the transcribed examples “could contain errors”.

It is, however, still runnable, and that is not trivial for a hobby artifact of this age. The reference interpreter is standard C with no dependencies beyond stdio.h, stdlib.h and stddef.h; on a current compiler it builds and executes the 2000-era sample programs unchanged - verified here with Apple clang on macOS, and there is nothing platform-specific in the source to suggest other Unix-like toolchains would differ. For anyone studying the minimalist branch of esoteric language design, Fromage is a complete, self-contained specimen you can build and run in a couple of commands:

1
2

cc -w -o fromage fromage.c
./fromage hello.fr

The -w is a convenience rather than a requirement - the interpreter’s obfuscated style provokes warnings on modern compilers (operator-precedence complaints around its bit shifts and comparisons), not errors.

Why It Matters

Fromage matters for what it demonstrates about a specific design question rather than for anything it was used to build.

It isolates the cost of granularity. Brainfuck and Fromage have nearly the same machine model; the difference is the size of a cell. Setting them side by side makes the consequence legible. In Brainfuck the expensive thing is arithmetic distance, and programs are dominated by long runs of +. In Fromage the expensive thing is spatial distance, and programs are dominated by long runs of <. Reducing the cell from a byte to a bit does not simplify programs; it relocates their bulk.

It shows that minimal instruction counts and structured control are compatible. Most minimalist esolangs reach their small instruction count by collapsing control flow to a single looping primitive. Fromage keeps three separate structured forms, and still lands at ten instructions, by spending its budget on control and starving data instead. That is an unusual point in the design space and a deliberate one.

It is an honest record of how esoteric languages actually got made. Fromage is one person’s first experiment, documented in the comments of its own cat program, distributed as a tarball on a personal homepage, and preserved by a volunteer mirror in another country. The language’s survival owes nothing to institutional support and everything to the archival habits of a small community - which is, in the end, how most of the esoteric-language canon reached us.