Brainfuck Chess, a Tiny Language Model, and Q Getting Serious (2026)

This window's most convincing argument for esolang programming is that the projects are no longer content to print Hello, World!. From July 5 through July 19, GitHub produced a complete chess rules engine written directly in Brainfuck, a tiny language model that is technically an autoregressive generator, and a serious open-source Q implementation with a browser REPL and kdb wire compatibility. 1 2 3

The three picks below are ranked by the channel's usual categories: one project that is pure showmanship, one that is gloriously unnecessary, and one that might actually help somebody do work. The scan ran over the July 5-19 window in UTC-05. Repository creation dates below come from GitHub's repository metadata; stars, forks, issues, commits, and language breakdowns are the values visible during this scan.

The three picks

Category	Project	Created	Language signal	Snapshot
Most show-off	`pkkkkkkkkkkkkk/brainfuck-chess`	July 12	Brainfuck 48.3%	91 commits, 1 star, 0 forks, 0 open issues
Most absurd	`ayomidelog/bf-slm`	July 13	Brainfuck 96.5%	3 commits, 1 star, 0 forks, 0 open issues
Most practical	`peachq-org/peachq`	July 10	C 99.8%, Q implementation	1,121 commits, 7 stars, 1 fork, 8 open issues

The first two are fresh builds in the obvious sense. peachq is the interesting edge case: the public repository was created in the window, but its README calls it a read-only release mirror of a private development repository. That makes it new to the public GitHub surface, not a brand-new codebase. 3

Most show-off: chess, but the tape decides

pkkkkkkkkkkkkk/brainfuck-chess is a complete local two-player chess game whose rules engine is authored directly in Brainfuck. The browser host runs the eight canonical instructions in a persistent Web Worker, sends move attempts to the machine, and renders the state that the machine returns. The README is explicit about the boundary: JavaScript does not contain a second chess rules implementation, a fallback validator, or a generated source layer. 1

That is already a good stunt. The repo then makes it difficult to dismiss as a stunt by listing ordinary moves, captures, check, checkmate, stalemate, promotion and underpromotion, en passant, castling, threefold repetition, the fifty-move rule, and insufficient-material draws. Illegal moves are transactional: a rejected attempt must not partially mutate the position, clocks, castling rights, history, or any other persistent tape cell. 1

The design is wonderfully hostile to conventional instincts. The 64 squares live inside a 10-by-12 sentinel mailbox on the tape, so movement can use fixed pointer deltas: 1 horizontally, 10 vertically, and 9 or 11 diagonally. Off-board probes hit 255 sentinels instead of asking the browser to do coordinate geometry. Each candidate move goes through a transaction path that classifies the pieces, checks geometry and obstruction, applies special-move side effects, tests the king, and restores the old position if the move fails. 1

The verification story is part of the flex. The project includes a strict test VM, an independent chess oracle, differential games, protocol checks, pointer and tape invariants, browser-VM comparison, and a static audit that rejects hidden chess decision tables in the JavaScript shell. The repository page shows 91 commits, Apache-2.0 licensing, one star, and no published release at the time of the scan. 1

Why it made the issue: most Brainfuck interpreters prove that Brainfuck can execute instructions. This project asks whether Brainfuck can own a rules-heavy state machine while a deliberately dumb browser merely carries bytes around. That is a much better show-off problem than another calculator.

Read next: open the browser build first, then inspect engine/brainchess.bf when the board starts making you suspicious.

Most absurd: the eight-instruction language model

ayomidelog/bf-slm describes itself as a Brainfuck Small Language Model and immediately adds the only responsible disclaimer: "Please do not put this on your resume." It is a character-level bigram and trigram model. A seed character or pair is fed into a hardcoded transition table, the predicted character is fed back as the next input, and the process repeats. The training pipeline is in Python; the generated models are Brainfuck. 2

The repository includes an English bigram model, a Nigerian Pidgin trigram model, a larger Pidgin v4 model, a Python interpreter with debug mode, a faster C interpreter, and a Brainfuck-to-C compiler. The author also supplies a training script with corpus, bigram/trigram, candidate-count, step-count, and output-file controls, so this is more than a README that calls a lookup table AI. 2

The scale comparison is the joke and the lesson. The README estimates roughly 17 parameters for the bigram model and 400 for the trigram model, against the familiar much larger parameter counts of modern language models. The entire bigram model fits in seven cells of a 60,000-cell tape, while a trigram generation step can run millions of Brainfuck operations. The claimed timing is about 0.5 seconds in Python versus 0.01 seconds in C for the bigram model, and 30 seconds or more versus 1-3 seconds for the trigram model. 2

It even has a modest attempt at escaping deterministic loops: the trigram model stores top-K candidates per context and uses entropy-based selection. In other words, somebody built temperature-adjacent behavior into a language whose normal debugging experience is counting plus signs. The result is not a competitive text generator, and the README says so. It is a compact demonstration that next-token prediction is a general computational pattern, not a magical property of modern ML stacks. 2

Why it made the issue: calling a seven-cell lookup table a language model is exactly the kind of technically defensible mischief this column is for. The implementation is real enough to train, run, compare, and optimize, but the project never loses sight of the fact that an abacus is also technically a computer.

Read next: try the pre-trained model with the repository's example command, then look at slm_pidgin_v4.bf and decide whether the output is text, prophecy, or a very slow typo.

Most practical: Q leaves the lab

peachq-org/peachq is an open-source implementation of the Q programming language, built on rayforce, a pure C17 columnar engine. It is not an esolang in the same deliberately punitive sense as Brainfuck or Malbolge, but Q belongs to the APL family and fits the channel's broader interest in array languages that compress an alarming amount of meaning into a small amount of punctuation. 3

This one has an actual practical target: behavioral compatibility with Q, measured through observable details such as parse display, type shorts, error text, and console formatting. The README lists q datatypes including temporal values, verbs and adverbs, lambdas, projections, dictionaries, tables and keyed tables, qSQL operations, kdb wire serialization, a server mode, and browser support through WebAssembly. It also provides a hosted REPL and downloadable binaries. 3

There is enough operational detail to make the project feel like software rather than a language fan page. You can build it with make, run a REPL, pipe 2+3 into it, start a kdb-wire server with ./q -p 5000, or try the browser version. The sample session includes keyed tables, grouped aggregation, temporal arithmetic, derived verbs, parsing, metadata, and wire serialization. 3

The important caveat is also right there: PeachQ is useful but early, and it is not yet a drop-in replacement for production kdb+/q systems. The public repository shows release v0.43 on July 17, 7 stars, 1 fork, and 8 open issues. Its contributor endpoint lists five contributors, while the repository page shows 1,121 commits. 3

Why it made the issue: this is the rare new Q-family entry that offers a credible reason to exist beyond demonstrating that the syntax can be parsed. The project is trying to make array-oriented data work portable, inspectable, and easier to try. That counts as practical even when the language still makes ordinary arithmetic look like a small typographic incident.

Read next: start with the online REPL, then check the compatibility dashboard before treating it as a production migration path.

The quiet corners were not empty

The rest of the scan had fewer candidates, but several deserved a note.

Malbolge: verymintyfresh/malbolgifier is an interactive Malbolge interpreter made in Godot, with one commit and no stars when checked. alialle/malbolge-sandbox is the more substantial companion: a from-spec interpreter implementing the three registers, 59,049 ten-trit memory words, the eight-instruction opcode table, the tritwise "crazy" operation, and the self-modifying cipher. It verifies a real Hello World and the spec's cat program. 4 5
Whitespace: CodesMaha/whitespace-implementation has 17 commits and a lexer, execution, and test layout, but currently supports only basic arithmetic. It accepts literal spaces, tabs, and newlines, plus visible aliases such as \\32 and \\t for people who would like their invisible program to be slightly less invisible. 6
Befunge: HJhajun/Befunge-IDE is a genuinely useful browser tool with a two-dimensional editor, selection transforms, undo/redo, a Befunge-93 runner, stepping, breakpoints, stack and output views, path visualization, loop heatmaps, and project save/open support. Befunge-98 is listed as planned, so this is a solid Befunge-93 IDE rather than a claim about a broader standard. 7
APL proper: SNAPKITTYWEST/legacy-apl is 100% APL and contains proof-oriented modules, but GitHub marked it archived on July 12. It is interesting evidence of activity, not a healthy new project to recommend as the practical pick. 8

A few Brainfuck near-misses made the shortlist painful: KutayX7/badapple-brainfuck turns every Bad Apple frame into valid Brainfuck that prints a smaller version of the same frame; duckdosa123-art/brainfuck-compiler writes a Brainfuck-to-C compiler in Brainfuck; and gaidardzhiev/ffvm proposes a virtual machine whose state lives in pixels while an FFmpeg filtergraph acts as the CPU. The last one is especially good, but its own README says the full VM is not yet implemented, which kept it in the honorable-mentions drawer. 9 10 11

The verdict

The old scoreboard was Brainfuck plus a lot of silence. This window is more interesting: Brainfuck has moved from interpreters and compilers into chess and toy language modeling, while Q has arrived with enough implementation depth to make the word "practical" feel earned. Malbolge, Whitespace, and Befunge are still producing smaller, quieter artifacts, but they are producing them.

The best project is probably brainfuck-chess, because it turns a joke premise into a falsifiable systems boundary. The funniest is bf-slm, because the author understands both the technical point and the joke. The one most worth watching is peachq, because a Q implementation with a REPL, WebAssembly, qSQL, and kdb-wire support can escape the esolang shelf and become a tool someone actually tries.

Brainfuck Chess, a Tiny Language Model, and Q Getting Serious