White paper, first installment of the Babel / Inflexión series. Style: Chicago author-date via pandoc + BibTeX. Voice: essayistic for curious minds. Citations are BibTeX keys ([@key]) and resolve through references.bib.

1. A field that has produced examples but not a method

An esoteric programming language is a programming language designed to test the boundaries of what a programming language can be. It is usually small, often deliberately impractical, sometimes a joke that turns out to be a research programme on second reading. The community at esolangs.org (Esolangs Contributors 2026b) has been cataloguing them for over two decades. The wiki currently lists something on the order of 1,500 entries. Its single largest category is Brainfuck derivatives (Esolangs Contributors 2026a), with around eight hundred languages. Each one is a re-encoding of the same eight-instruction tape machine that Urban Müller distributed in 1993 (Müller 1993), differing in surface form, in cell width, in alphabet, or in cultural skin.

Read sympathetically, this is a remarkable creative output. Read carefully, it is also a strange artefact. Eight hundred authors took the same starting point and did the same kind of restructuring work, mostly without referring to each other’s tools or inheriting each other’s scaffolding. The field has produced a corpus but not a methodology. It has discovered the variation axes its languages move along, including cell width, tape topology, instruction count, surface vocabulary, and cultural theme, without ever consolidating them into a parameter schema that a new author could pick up and use.

The closest analogues elsewhere in computing are the long-running obfuscation contests. The International Obfuscated C Code Contest has run annually since 1984 (IOCCC Organisers 2026), and the Obfuscated Perl Contest ran through the late 1990s (The Obfuscated Perl Contest, n.d.). Those communities accept programs that are formally correct, executable, and unreadable without dedicated study. They explore the same gap that esoteric languages do, the gap between what compiles and what communicates, but from inside an existing language. The esolang field plays the same game from outside. It builds new languages that hold the gap open by design. Both communities have learned, in their own ways, what kinds of constraint produce interesting strangeness. Neither has produced a tool that would let the next contributor inherit that learning.

This paper proposes that tool. Babel is a methodology for the programmatic construction of esoteric programming languages, plus the parameter schema and runtime that make the methodology operable. The argument is that making the field’s tacit variation axes explicit, and providing a runtime that turns chosen parameter values into a working language, changes the economics of designing esoteric languages. It is a lever on the next eight hundred attempts, not on the existing eight hundred.

2. What an esoteric language is, for the purposes of this paper

The wiki at esolangs.org takes a generous view of what counts as esoteric. The category includes Turing-complete languages, sub-Turing languages, deliberately undecidable jokes, languages that exist as a single program, and languages that are formally identical to existing ones with one or two cosmetic substitutions. For the purposes of this paper, an esoteric programming language is one with at least the following features.

It has an executable semantics. There is a clear answer, in principle, to the question what does this program do? This excludes pure performance art and language-as-poetry projects, however adjacent they may be culturally. It has a small surface area, typically a few dozen instructions or fewer, often fewer than ten. This excludes the heavyweight production languages such as Java and Python, and the small but architecturally rich ones such as Forth and Lua that aim to be genuinely useful at scale. And it has a deliberate constraint or strangeness. The language was designed to be in some way interesting rather than useful, where the interest comes from a chosen restriction, addition, or framing that production languages would not adopt.

These criteria admit Brainfuck, with eight instructions and deliberate minimalism; Whitespace, where only spaces and tabs are syntactic; Befunge, with its two-dimensional source grid; Shakespeare, where English-language plays serve as syntax; Wenyan, where Classical Chinese grammar serves as syntax (Huang 2019); INTERCAL, with its deliberately user-hostile error messages; and Piet, where the program is a bitmap. They exclude general-purpose languages with eccentric communities such as Lisp and Smalltalk, code-golf languages such as J and K whose goal is shortness rather than constraint, and pure jokes with no executable semantics.

The criteria are not particularly novel. The community has converged on something like them implicitly. Stating them explicitly matters because the parameter schema in the next section depends on having a definite class of artifact to parameterise. A schema that tried to cover everything, including production languages, code-golf languages, executable poetry, and esolangs proper, would be too loose to be useful. Babel parameterises the class of language that meets the three criteria above.

3. The variation axes the field has implicitly used

The eight hundred Brainfuck derivatives, taken as a sample, vary along a small number of axes. Reading widely across the corpus suggests the following partition.

The base machine. Every esoteric language has an underlying execution model, the abstract machine its programs run on. The corpus uses, in approximate order of frequency: tape machines such as Brainfuck and its derivatives, stack machines such as FALSE and GolfScript, machines with a single instruction set such as Subleq and BitBitJump, two-dimensional grid machines such as Befunge and Hexagony, register-and-jump clones of assembly, queue machines such as Fueue, string-rewriting systems such as Thue and Markov-style rewriters, and a handful of more exotic machines including combinator calculus and cellular automata as program. The base machine is the largest single design choice and everything else parameterises it.

Memory shape. Within a given base machine, the memory has a shape. It might be a one-dimensional unbounded tape, a one-dimensional circular tape, a two-dimensional torus, a stack of fixed depth, an unbounded stack, a queue, a deque, or a graph. Brainfuck’s standard memory is a one-dimensional unbounded tape of byte-sized cells; Boolfuck uses a tape of bit-sized cells; Brainfuck Extended uses integers of arbitrary precision.

Cell width. Closely related but separable: the size of an individual cell. Bit, nibble, byte, word, arbitrary precision. Some languages allow signed values, some unsigned, some only positive.

Instruction count and set. A derivative of Brainfuck might use the canonical eight instructions, a subset like Boolfuck, a superset such as Brainfuck with debug or randomness, or a non-overlapping replacement. The instruction count typically ranges from one, in OISC machines, to a few dozen in richer fungeoids. Larger instruction sets are usually re-encodings of small ones rather than truly novel additions.

Encoding. Once an instruction set exists, it has to be encoded in source text. The canonical Brainfuck encoding uses ASCII punctuation: > < + - . , [ ]. Whitespace encodes its instructions in tab/space/newline triples. Unary encodes its entire program as a single integer expressed in base-1. Binary, base-N, and encodings keyed on natural-language words are all options.

I/O model. Character at a time is the dominant pattern. Some languages take whole-line input, some take an integer, some take no input and produce no output so the program’s effect is its own internal state at termination, and some treat the file system as I/O.

Additions and removals. Many derivatives are characterised primarily by what they add to or subtract from a base. La Weá adds a clipboard register to Brainfuck’s eight instructions. Chespirito adds an instruction for randomness. Brainfuck Lite removes the loop instructions. These additions and removals are the design choices that distinguish a derivative from its base. They are also where the most interesting work in the corpus lives.

Theming. Orthogonal to all the above is the surface theme, the cultural skin laid over the instruction set. Cooking in Chef, Shakespearean play in Shakespeare, action-movie quotes in ArnoldC, Schwarzenegger catchphrases also in ArnoldC, Chilean slang in La Weá, literary Chinese of the 19th century in Wenyan. Theming changes how the language reads without necessarily changing how it executes. It is the most visible design choice and often the one a new author chooses first. It is also, on its own, the cheapest contribution one can make to the corpus.

These eight axes, namely base machine, memory shape, cell width, instruction count and set, encoding, I/O, additions and removals, and theming, between them account for most of the variation across the corpus. They are not the only possible axes, and Babel’s schema in the next section will need to be open to additions. The third installment in this series (Rodriguez 2026b) takes up an adjacent field, the design of programming languages oriented to LLMs, that surfaces further axes the original eight cannot cleanly express. Those extensions are developed there, against that field’s design choices, and are not folded into the present paper. The original eight are the foundation. Any later extensions sit on top of them.

4. Babel’s parameter schema

Babel proposes that an esoteric programming language can be specified, for the purposes of generation, as a parameter set across the axes inventoried in §3 plus a small number of meta-parameters that describe the language’s character rather than its mechanism.

The mechanical parameters follow §3 directly: base machine, memory shape, cell width, instructions given as token and operation, encoding, I/O model, additions, removals, and theme. A parameter sheet in YAML, the format the runtime consumes, collects these into a single document. The instruction set is given as a list of (token, op) pairs, where the canonical operation names form a fixed vocabulary the runtime dispatches on. That vocabulary covers pointer movement, cell modification, loop bracketing, I/O, plus a small set of well-known additions like a clipboard register or a halve primitive. New canonical operations are added to the runtime’s vocabulary as the corpus surfaces them. The schema’s openness lives there.

The meta-parameters are different in kind. They are knobs on what the resulting language feels like to read and write, not knobs on its mechanism. The proposed set of meta-parameters follows.

Complexity measures the cognitive cost of writing a non-trivial program. A Subleq machine has high complexity since it has one instruction and produces large programs. Brainfuck has medium complexity. A richer fungeoid like Befunge has lower complexity per useful program.

Abstraction measures the gap between surface syntax and execution model. Brainfuck is low in abstraction since the instructions correspond directly to operations on the tape. Shakespeare is high, since a soliloquy assigns a value through letter counts and metaphor. Wenyan is high in its surface syntax but lower in its underlying semantics.

Verbosity measures bytes per logical operation. Chicken, with one token and repetition-encoded, is hyper-verbose. Brainfuck is moderate. J and K, with single-byte tokens, are hyper-compact.

Playfulness measures the language’s self-conscious humour, parody, or theatricality. INTERCAL, Chef, ArnoldC, and Fetlang are high in playfulness. Subleq is low.

Unpredictability measures the degree to which the same program can produce different results across executions, or the degree to which the language’s behaviour deviates from the programmer’s reading of the source. Whenever, which executes statements when it feels like it, is high in unpredictability. Malbolge is high in a different way, since the instruction effect depends on the address. A deterministic Brainfuck is low.

Naturalness measures how closely the language’s surface syntax follows a natural-language grammar. The framing as a single value first proposed for this axis turned out to be too coarse, as the decompositions of Wenyan and Inflexión in §6 demonstrate. Under one value, Mierda and Inflexión both reported as “naturalness involving Spanish,” collapsing a real structural difference. Mierda substitutes vocabulary; Inflexión engages grammar. The parameter resolves into three sub-values:

• Vocabulary substitution. The language’s keywords are natural-language words but the grammar is otherwise that of a standard PL with English keywords. Mierda, La Weá, Chespirito, BIRL, ArnoldC, and Monicelli sit here.
• Lexical-grammar engagement. The language uses natural-language morphology or word order in a partial way: a few syntactic rules driven by inflection over otherwise-standard PL grammar. LOLCODE, Shakespeare, and Rockstar approximately sit here. The position is sparsely populated relative to the other two.
• Deep-grammar engagement. The language’s parser handles the substrate language’s actual grammatical constructions, including agreement, case, mood, aspect, clitic systems, and particles in their literary positions. Wenyan, Perligata, Tampio, and Inflexión (Rodriguez 2026a) sit here.

A language can sit at any of the three levels independently of its other parameters. The decomposition resolves the naturalness coarseness that the original single value carried. The four-value version surfaced in the wider field of LLM-oriented design (Rodriguez 2026b) adds a corner for the anti-human-readable that does not apply to the esolang corpus this paper treats.

The meta-parameters are not independent of the mechanical parameters. Verbosity is partially a function of encoding and instruction count. Naturalness is partially a function of theming. Unpredictability sometimes leaks out of the instruction set, since a derivative of Brainfuck that adds a randomness primitive picks up nonzero unpredictability without changing any meta-parameter explicitly. The point of including the meta-parameters anyway is that they capture the design intent at a level a new author thinks at. A new author rarely starts with “I want a one-dimensional unbounded tape with byte-sized cells.” They start with “I want something playful, high in verbosity, themed around X, primarily readable by humans.” The meta-parameters let Babel meet the author at that level and resolve down to the mechanical parameters as a second step.

This schema of two layers is the methodological contribution. The field has had the mechanical axes available implicitly for thirty years. What it has not had is a vocabulary at the level of design intent that can be turned into a working language without each author rebuilding the same scaffold.

The schema is incomplete by design. The naturalness axis still risks coarseness within its three values. The additions axis is doing implicit work for evaluation strategy, effect model, and toolchain targets in ways future installments will need to break apart. The pattern of revision is the one §6 demonstrates: decompose existing languages against the schema, find the cells where the decomposition is muddy, extend or split the axis. The schema improves through friction with real artifacts rather than through theorising.

5. Three output targets, three readers

A parameter set is not a language. To turn a Babel parameter sheet into a usable artifact, the runtime produces three outputs.

The first is a runnable interpreter for the generated language. The shipped runtime is implemented in Python and reads source files written in the new language, executing them against the chosen semantics of the base machine. The interpreter’s role is to make the generated language real. A language without a working executor is a specification, not a programming language. The interpreter is also the artifact most useful to students and casual users, who can pick it up and run programs without engaging Babel itself.

The second is a transpiler that converts source in the generated language to a chosen target language, typically the language of its base machine, such as vanilla Brainfuck for generations of Brainfuck derivatives. This lets programs written in the new language run via existing toolchains. The transpiler matters for two reasons. It makes generated languages composable with tools already in the ecosystem; and it provides a second execution path that can serve as a sanity check on the interpreter.

The third is a specification page in the format of a wiki entry on esolangs.org, giving the language’s name and version, mechanical and meta-parameter values, instruction reference with surface tokens and canonical operations, additions and removals, and any example programs the parameter sheet carries. The specification is the artifact that joins the discourse. It is what other esolang authors read, what wiki maintainers can index, what reviewers cite, and what later installments of this project can refer back to. A generated language without a specification is a private toy.

Three outputs serve three readers: the user who runs programs, the developer who integrates with existing infrastructure, and the writer who joins the wiki community. None of the three is more important than the others. What matters is that the methodology produces all three from one parameter set, in lockstep, without each author having to reproduce the spec by hand from a working interpreter. §7 shows the three outputs for a concrete example.

6. Retrospective decompositions

The methodology can be tested by decomposing existing esoteric languages into their would-be Babel parameters. If the decomposition is clean, meaning the parameter sheet for an existing language picks out exactly that language and not its neighbours, the schema is doing useful work. If the decomposition is muddy, the schema needs revision. Four worked decompositions follow, drawn from the Spanish- and Chinese-flavoured corners of the corpus where the naturalness axis is most visibly load-bearing.

Mierda (Esolangs Contributors, n.d.-b) is a derivative of Brainfuck with Spanish keywords. Its Babel parameter sheet would read: base machine = Brainfuck tape; memory shape = one-dimensional unbounded; cell width = byte; instruction count = 8; instruction set = {Mas, Menos, Derecha, Izquierda, Decir, Leer, Iniciar Bucle, Terminar Bucle}; encoding = tokens of natural-language keywords separated by whitespace; I/O = character; additions = none; removals = none; theme = Spanish vocabulary. Meta-parameters: complexity medium, abstraction low, verbosity medium-high since the natural-language keywords inflate token length, playfulness moderate, unpredictability zero, naturalness vocabulary substitution. The decomposition is clean. Every cell of the parameter sheet is filled in unambiguously, and the resulting parameter sheet picks out Mierda specifically.

La Weá (Esolangs Contributors, n.d.-a) is a derivative of Brainfuck with Chilean Spanish and one significant addition, a clipboard register that stores a single byte separately from the tape. Its parameter sheet matches Mierda’s on the mechanical axes except: instruction count = 16; instruction set = sixteen tokens in Chilean slang; additions = clipboard register with two associated instructions for store and recall; theme = Chilean dialect. Meta-parameters: similar to Mierda but with higher playfulness, since the dialect register carries comic weight, and vocabulary substitution naturalness at the dialect end of the scale. Chilean slang is further from “neutral” Spanish vocabulary, which makes it more culturally specific even though no grammar is engaged. The decomposition picks La Weá out from Mierda specifically by virtue of the clipboard register on the additions axis and the dialect-specific theme.

Wenyan (Huang 2019) is harder and was the case that first surfaced the naturalness coarseness now formalised in §4. Its base machine is procedural and variable-based, with named variables, conditionals, loops, and functions, closer to a stripped-down ALGOL family than to a tape machine. Memory shape = a model of named variables with no fixed shape; cell width = arbitrary-precision integer or string; instruction count = several dozen, organised into syntactic categories such as declarations, control flow, and arithmetic rather than into primitive operations; encoding = Classical Chinese characters and particles such as 者, 也, and 而 in their literary positions; I/O = whole-line via standard input and standard output; additions = compilation to JavaScript, Python, and Ruby targets; theme = literary register of Classical Chinese. Meta-parameters: complexity moderate, abstraction high, verbosity moderate, playfulness moderate, since the language is taken seriously by its community, unpredictability low, naturalness deep-grammar engagement, since the parser handles real Classical Chinese grammar rather than substituting vocabulary.

Inflexión (Rodriguez 2026a) is the case that confirms the deep-grammar level needs to be a level rather than a binary. Its parameter sheet under the old single-value naturalness would have collided with Wenyan. Under the three sub-values it picks out the same level but a different substrate language. Base machine = procedural and variable-based, with explicit mutability typed through the split between ser and estar; memory shape = named-variable; cell width = arbitrary-precision and typed; instruction count and set = the six mappings of grammar to semantics in §3 of the companion paper, each carrying one Spanish grammatical feature with a programming-semantic role; encoding = Rioplatense Argentine Spanish surface forms with .infl file extension; I/O = character via decí, the vos imperative; additions = the six mappings as joint feature set; theme = Rioplatense cultural register. Meta-parameters: complexity moderate, abstraction high, verbosity low, since morphological packing carries semantic distinctions without expansion, playfulness moderate, unpredictability zero, naturalness deep-grammar engagement. The decomposition picks Inflexión out from Wenyan specifically via the substrate language, Rioplatense Spanish versus Classical Chinese, the additions set consisting of ser, estar, mood, aspect, clitic, and diminutive, and the encoding of vos imperatives and enclitic pronouns.

Four decompositions, two of which, Mierda and La Weá, ran cleanly against the original schema, one of which, Wenyan, forced the naturalness coarseness into the open, and one of which, Inflexión, confirmed that the three-value naturalness decomposition is the right repair. The methodology is doing what a methodology should do: friction with new languages surfaces gaps; gaps drive schema extensions; the schema improves through use rather than through theorising. The companion paper develops Inflexión in detail (Rodriguez 2026a). The wider field of LLM-oriented PL design, which decomposes against further axes the present schema does not carry, is the subject of the third installment (Rodriguez 2026b).

7. A forward example: Brainfuck Rioplatense

A retrospective decomposition tests the schema against an existing language. A forward example tests the runtime against a parameter sheet. Both are necessary. Together they close the loop the methodology promises.

Suppose an author wants a small esoteric language with the following design intent. Themed around the Argentine Rioplatense dialect, with voseo. A Brainfuck derivative as base for ease of implementation. Eight instructions, with naturalness only at the level of vocabulary substitution and no grammar engagement; that is the companion language’s territory. Moderate playfulness. Add one instruction that reflects something distinctive about the dialect: the diminutive suffix as an operation that halves the current cell.

The author writes a YAML parameter sheet. The file ships as examples/brainfuck-rioplatense.yaml in the runtime distribution:

name: "Brainfuck Rioplatense"
version: "0.1.0"
base_machine: brainfuck_tape
memory_shape: 1d_unbounded
cell_width: byte
encoding: whitespace_separated_tokens
io: character
source_extension: ".bfri"
theme: "rioplatense_argentine"

instructions:
  - { token: "che",      op: ptr_right,  description: "Advance the data pointer (Argentine vocative)." }
  - { token: "vení",     op: ptr_left,   description: "Retreat the data pointer (vos imperative)." }
  - { token: "más",      op: increment,  description: "Increment the current cell." }
  - { token: "menos",    op: decrement,  description: "Decrement the current cell." }
  - { token: "decí",     op: output,     description: "Output the current cell as a character (vos imperative)." }
  - { token: "escuchá",  op: input,      description: "Read one character into the current cell (vos imperative)." }
  - { token: "mientras", op: loop_start, description: "Enter loop body if the current cell is nonzero." }
  - { token: "ya",       op: loop_end,   description: "Exit loop or loop back (Rioplatense terminative particle)." }
  - { token: "ito",      op: halve,      description: "Halve the current cell (diminutive suffix)." }

additions: ["halve_via_diminutive_suffix"]
removals:  []

meta:
  complexity:       medium
  abstraction:      low
  verbosity:        verbose
  playfulness:      moderate
  unpredictability: zero
  naturalness:      vocabulary

The sheet is short, under fifty lines including comments. The author runs three commands against it. Each command corresponds to one of the three output targets in §5.

Output 1, the interpreter. The canonical “print the letter A” program rewritten in Rioplatense tokens runs end-to-end against the generated interpreter:

$ babel run examples/brainfuck-rioplatense.yaml \
    --program "más más más más más más más más mientras che más más más más \
               más más más más vení menos ya che más decí"
A

The interpreter reads the whitespace-separated tokens, dispatches each through the YAML’s instruction table to the canonical operation, and executes against a one-dimensional unbounded byte tape. The program prints the byte 65 ('A') and halts.

Output 2, the transpiler. The same program transpiles to vanilla Brainfuck:

$ babel transpile examples/brainfuck-rioplatense.yaml \
    --program "más más más más más más más más mientras che más más más más \
               más más más más vení menos ya che más decí"
++++++++[>++++++++<-]>+.

The transpiler maps each surface token through the same instruction table to the canonical operation, then re-encodes each canonical operation as its vanilla-Brainfuck token. The lowering for the halve_via_diminutive_suffix addition is more interesting. A program that uses ito, the only mechanical departure from canonical BF, transpiles to vanilla BF’s divmod idiom, since vanilla BF has no halve primitive:

$ babel transpile examples/brainfuck-rioplatense.yaml \
    --program "[130 'más' tokens] ito decí"
+++…+++>++<[->-[>+>>]>[+[-<+>]>+>>]<<<<<]>>>[-<<<+>>>]<<<>[-]>[-]<<.

The lowered program halves 130 to 65 using a six-instruction loop that decrements the source cell twice for every increment of a scratch cell. The author of the Rioplatense parameter sheet never wrote that loop; the runtime emitted it from the canonical halve operation. This is the kind of work the methodology saves a new author.

Output 3, the specification page. The spec generator emits a Markdown wiki-style page directly from the parameter sheet:

$ babel spec examples/brainfuck-rioplatense.yaml
# Brainfuck Rioplatense — Specification

*Version 0.1.0. Generated by Babel runtime.*

## Overview

Vocabulary-skin Brainfuck derivative themed around the Argentine
Rioplatense dialect with voseo. Adds one diminutive-as-halve instruction
(the only mechanical departure from canonical BF).

## Mechanical parameters

| Parameter         | Value                          |
| ----------------- | ------------------------------ |
| Base machine      | brainfuck_tape                 |
| Memory shape      | 1d_unbounded                   |
| Cell width        | byte                           |
| Encoding          | whitespace_separated_tokens    |
| I/O model         | character                      |
| Theme             | rioplatense_argentine          |
| Source extension  | .bfri                          |

## Instruction set

| Token    | Operation  | Description                                    |
| -------- | ---------- | ---------------------------------------------- |
| che      | ptr_right  | Advance the data pointer (Argentine vocative). |
| vení     | ptr_left   | Retreat the data pointer (vos imperative).     |
| más      | increment  | Increment the current cell.                    |
| menos    | decrement  | Decrement the current cell.                    |
| decí     | output     | Output the current cell as a character.        |
| escuchá  | input      | Read one character into the current cell.      |
| mientras | loop_start | Enter loop body if the current cell is nonzero.|
| ya       | loop_end   | Exit loop or loop back.                        |
| ito      | halve      | Halve the current cell (diminutive suffix).    |

...

The complete spec page continues with the list of additions, the meta-parameter table, and the example programs the YAML carries. The full output is included alongside this paper as generated/brainfuck-rioplatense/specification.md.

The three outputs were produced from the one parameter sheet by three CLI commands. No additional authoring was required between the sheet and any of the three artifacts. A new author who wanted to produce this language hand-rolled would spend an evening writing a small interpreter; if they wanted a transpiler and a wiki-style spec page they would spend a second evening. With Babel they fill in a parameter sheet, run three commands, and the three outputs are produced together, in lockstep, without ever drifting out of sync.

The example is deliberately modest. The point is not that Brainfuck Rioplatense is interesting on its own. It is a vocabulary-skin Brainfuck derivative with one minor addition, and the existing corpus already contains many such. The point is that its parameter sheet is short, fillable, and unambiguous, and that the three outputs follow from it mechanically. The interesting design choice is the halve primitive, surfaced from the dialect’s productive diminutive morphology. That is the kind of work the methodology is designed to leave room for. The author chose the addition, and the runtime did the lowering. That is the division of labour the methodology proposes.

8. Educational and academic value

The methodology has value for three audiences at three levels of engagement.

For students, Babel makes the field’s variation axes legible without requiring the student to first build a working interpreter from scratch. A class on the design of programming languages can walk through the parameter schema as a taxonomy of design choices, with examples drawn from the corpus, and assign a project that is no longer “build an esoteric language,” a vague brief that produces uneven work, but “fill in this parameter sheet, run it through Babel, and write a one-page rationale for your choices.” The student learns the same material and produces a comparable artefact, but the focus is on the choice of parameters, which is where the design thinking actually lives. The work the student saves on plumbing is reinvested in the work that matters.

For researchers, Babel provides a shared vocabulary for talking about what makes one esoteric language different from another. The current literature on esolangs, such as it is, relies on prose comparison and intuition. A parameter schema gives reviewers, citation-writers, and survey-paper authors a more compact way to summarise a language’s design. It is the same kind of contribution that the features of typological linguistics make to comparative grammar work: not a substitute for careful prose, but a scaffold on which careful prose can be built more efficiently.

For language designers working in adjacent territory, including people designing constrained languages, controlled natural languages (Fuchs et al., n.d.; Nelson, n.d.), domain-specific languages with deliberate strangeness, or pedagogical mini-languages rather than pure esolang authors, Babel’s schema provides a sanity check on which axes have already been varied in the esolang corpus and which combinations are unexplored. A designer who finds their parameter sheet matching an existing esolang exactly is reinventing; one whose sheet does not match anything is exploring.

The field’s historical literary precedents all suggest that technical artefacts are at their most useful when they are accompanied by the language to talk about them. Cheswick narrated a security incident as a story (Cheswick 1992). Raymond’s edition of the Jargon File (Raymond 1996) is a vocabulary that does cognitive work. Kidder portrayed a minicomputer team as a story of human effort (Kidder 1981). Babel is, in part, an attempt to give the esolang field that language.

9. What this is not

Three things Babel is explicitly not.

It is not a toolkit for production languages. The interpreter and transpiler outputs are intended for use, not for performance. There is no JIT, no optimisation, no profiling support, and no debugger beyond what the generated language’s own semantics provide. The argument is not that production-grade tooling is undesirable; it is that production-grade tooling is the next problem, and conflating it with the methodology problem would muddy both.

It is not a replacement for hand-craft. Some of the most interesting languages in the corpus, including Malbolge, Piet, Velato, Folders, and Vigil, depend on creative leaps that no parameter schema can capture. Malbolge’s mechanism, where the instruction effect depends on the memory address, is not a value of any reasonable parameter. It is an idea. Babel is for the languages that are parameter-driven, which, per the corpus, is most of them, and it is meant to free up author energy for the ideas that aren’t.

It is not finished. This is the first installment. The parameter schema as presented has at least one known limitation. The additions axis is doing implicit work for evaluation strategy, effect model, and toolchain targets that future revisions will need to split apart. It presumably has others that will surface as the runtime is exercised against further corpus entries. The methodology will improve through use. A first installment that pretended to be complete would be both dishonest about its stage and unhelpful to whatever future author tries to push the work forward.

10. What comes next

The companion paper (Rodriguez 2026a) develops one specific instantiation of the design space Babel proposes to parameterise: a hand-built esoteric language that engages Spanish grammar, including number, mood, aspect, ser and estar, clitic ordering, and diminutive morphology, as the source of programming semantics rather than as theme. The companion paper joins a small lineage of esolangs driven by inflection in non-English natural languages, namely Perligata in Latin, the unimplemented Espro in Esperanto, Tampio in Finnish, and Wenyan in Classical Chinese. It is the first in that lineage to use a living Romance language (Conway 2000; Timwi 2015; Hauhio, n.d.; Huang 2019; Esolangs Contributors, n.d.-a). That language is not generated by Babel and is not constrained by Babel’s parameter schema. The choice to hand-build it was made to keep the language design free of any tooling limits not yet discovered. Once both Babel and the companion language exist as working artefacts, a future installment can ask whether Babel’s parameter schema can express the companion language. The answer, whatever it is, will be informative about the schema. The companion language is catalogued on the esolangs.org wiki at https://esolangs.org/wiki/Inflexión.

The third installment (Rodriguez 2026b) treats the parallel field of LLM-oriented PL design as an adjacent corpus and extends Babel’s parameter schema to cover it. That extension does not bear on the esolang material in the present paper. It is developed against the LLM-oriented field’s own design choices, in its own paper, where the audience is the one whose work the extensions address.

Further installments of this paper will address: refinement of the naturalness sub-parameters as the corpus surfaces gradient cases within each of the three values; decomposition of the additions axis into the sub-axes for evaluation strategy, effect model, and toolchain target that the schema currently flattens; and an empirical comparison of hand-rolled and Babel-generated language production effort, sufficient to support or refute the order-of-magnitude claim in §1.

The vertical-slice runtime ships with this installment as babel-runtime v0.7.0, a Python package with parameter sheets for vanilla and Rioplatense Brainfuck plus fifteen other example languages drawn from across the corpus, namely Ook, Alphuck, Baguafuck, German, Pikalang, Spoon, Wordfuck, Mierda, La Weá, Chespirito, FALSE, Befunge, minimal-stack, Subleq, and fungeoid. All run end-to-end through the interpreter. All generate spec pages through the spec emitter. The Brainfuck-derivative family additionally transpiles to vanilla BF. A small browser playground at babel.roderickc.com exposes the runtime to readers without a local install: pick a parameter sheet for either vanilla Brainfuck or Rioplatense Brainfuck, type a program, watch it run.

The series is the unit of work. This first installment is meant to be readable on its own, but its main value is in establishing the methodology and the vocabulary the rest of the series will build on.

11. A closing note

Esoteric programming languages are usually read as a joke first. Read again, slowly, they are a research programme on what mainstream programming languages quietly assume about syntax, about state, about how a program is supposed to communicate with the person reading it. The two readings are not in conflict. The joke is real, and the research programme is real.

The field has carried the research programme for thirty years on the energy of individual practitioners working in parallel, mostly without inheriting each other’s tools. That work has produced an enormous corpus and proportionally little methodology. Babel is offered as a methodology, specifically one that lets the field’s tacit variation axes be made explicit, parameterised, and turned into working languages with three outputs in lockstep. The contribution is not a new esoteric language. It is a technique for making esoteric languages, of the kind a museum acquires only after it has accumulated enough specimens for the curation to start mattering.

A methodological note worth carrying through future installments: this paper’s approach to its own novelty claims has been honest preparation, writing down where pushback is expected and looking for the precedents that would falsify the claims before review rather than after. The lineage acknowledged in §10 surfaced through exactly this practice. A pre-publication literature check intended as confirmation found four prior authors whose work shifted the companion paper’s framing from first to fifth in a small lineage. The same discipline applies forward: any author using Babel whose parameter sheet matches an existing entry is reinventing rather than extending, and the schema’s value depends on authors being willing to discover that before the wiki community does.

A wider observation, treated more fully in the LinkedIn series accompanying this paper: technical vocabulary in mainstream programming languages is a deliberate register that strips cultural and historical context from the words it borrows. Daemon loses Hesiod’s daimon. Cookie loses the bakery. Fork loses both cutlery and the road. The strip-down is useful but not free: the weight remains available to a careful reader and invisible to a casual one. The esoteric-language field has often moved in the opposite direction, letting cultural weight be visible at the cost of portability. Babel’s theming axis in §3 names this design choice explicitly so it is no longer silently inherited. The companion paper (Rodriguez 2026a) develops the move further, building a language whose grammar, not only vocabulary, engages cultural specificity.

The next eight hundred attempts can be different from the last eight hundred.

Authorship and contribution

This is the first installment of a planned series on the construction of esoteric programming languages and on the role of culture and language in computing technology. It is authored by Ramon Rodriguez under the auspices of RCI. The series welcomes additional authors and collaborators; correspondence to be directed through RCI publication channels.

The companion paper, Inflexión: A Spanish-Grammar Esoteric Language (Rodriguez 2026a), treats one hand-built instantiation of the design space this paper opens. The third installment, LLM-Oriented Programming-Language Design: A Methodology (Rodriguez 2026b), extends the present paper’s schema against an adjacent field.

Acknowledgements

To the esolang community for thirty years of patient corpus-building. To Urban Müller for the eight instructions everything else is a derivative of. To the wiki maintainers at esolangs.org for the catalogue that made the survey possible. To the early readers whose pushback shifted the paper from a single sweeping schema-for-everything to the esolang-focused first installment it is now, with the LLM-oriented work moved to a third installment where it belongs.

References