A spreadsheet that runs Brainfuck, Qwen2.5-1.5B written out as 11.4 billion characters of Brainfuck, and an LLVM backend that emits Brainfuck
Three Brainfuck projects from the past fortnight: a spreadsheet that runs Brainfuck on formulas alone, Qwen2.5-1.5B written out as 11.4 billion characters of Brainfuck, and an LLVM backend that compiles C and Rust down to the tape.
Three repositories from this fortnight each take a language with eight or fewer instructions and give it a job nobody asked for.
lambdaS-zh/brainfuck.xlsx is a Brainfuck interpreter with no program in it at all — only spreadsheet formulas. rutgerklamer/brnfck-chat is a chat model you can talk to, where the answering program is 11,430,468,880 characters of Brainfuck. hmeyer/llvbf is an LLVM backend, so C and Rust arrive at the tape through a real compiler. 123All three were created between October 12 and October 25, 2026, UTC-05:00. Every figure below is the project's state during this run's verification pass.
The three picks
| Category | Project | Created (UTC-05) | What it does | Snapshot |
|---|---|---|---|---|
| Most absurd | lambdaS-zh/brainfuck.xlsx | Oct 18, 09:03 | A complete Brainfuck interpreter built from spreadsheet formulas | 1 commit; 0 stars; 0 forks; no licence 1 |
| Most show-off | rutgerklamer/brnfck-chat | Oct 12, 16:01 | Qwen2.5-1.5B written out as 11,430,468,880 characters of Brainfuck | 59 commits; 1 star; 0 forks; MIT 2 |
| Most practical | hmeyer/llvbf | Oct 23, 00:49 | An LLVM backend that compiles C and Rust down to Brainfuck | 31 commits; 0 stars; 0 forks; MIT 3 |
Most absurd: eight commands, zero lines of code
The workbook is called
brainfuck.xlsx and it weighs 18,110 bytes. 1 Inside it, all eight Brainfuck instructions are implemented in LET, LAMBDA, REDUCE, SCAN, HSTACK and dynamic arrays. There is no VBA, no macro and no script anywhere in the file.The interpreter runs the way the rest of the workbook does. You type a program into one cell, type any input into another, and the grid fills with the output.
Four pieces of engineering carry it. The first is a bracket table: a recursive
match_brackets walks the source once and pairs every [ with its ], so jumps become lookups instead of scans. 1The second is a memory model the grid can afford. A spreadsheet has no unbounded row of cells, so the tape becomes a sparse array of
[address, value] pairs holding only the non-zero cells, collapsed periodically with UNIQUE to keep the list from growing without limit.The third is optimization, borrowed from ordinary compilers:
+++++ becomes one instruction carrying the operand 5, [-] becomes a single clear, [>+++++>+<<-] compiles to one multiply-add, and MOD(val, 256) becomes BITAND(val, 255).The fourth is the reason the other three matter. WPS Spreadsheets caps
LAMBDA recursion at a depth of about 100, and a linear recursion at that depth executes only a few thousand instructions. 1So the interpreter recurses as a binary tree instead. A
fork call invokes fork up to two more times, which means 100 levels of recursion are 2^100 − 1 executable frames. The tree also stops growing once the emulated program halts and the program counter stops changing, so most of that number is never executed.That is the recursion cap turned into a feature: a tree of spreadsheet function calls standing in for a loop.
The README asks for WPS Spreadsheets with
LET, LAMBDA and dynamic arrays, and warns that functions such as REGEXP carry different meanings across spreadsheet engines, so Microsoft Excel may not run the workbook correctly. 1One honest detail from the author's own note: the workbook started about a year earlier, around 2025, as a weekend experiment about how far a spreadsheet's pure-functional model could go. The repository is the publication, dated October 18, of work done well before it. It holds a single commit, carries no licence and has no stars.
Most show-off: a language model that is 11 billion characters long
brnfck-chat runs six chat models as Brainfuck programs. Five of them carry Qwen weights, one of those with an image encoder attached, and the sixth carries SmolLM2-135M. A Qwen2.5-Coder was also trained to answer with Brainfuck source instead of prose. 2The sizes are the headline:
| Program | Model | Characters |
|---|---|---|
brnfck-smollm2-135m | SmolLM2-135M-Instruct | 1,030,902,380 2 |
brnfck-qwen2.5-0.5b | Qwen2.5-0.5B-Instruct | 4,169,659,608 2 |
brnfck-qwen2.5-1.5b | Qwen2.5-1.5B-Instruct | 11,430,468,880 2 |
brnfck-qwen3.5-0.8b | Qwen3.5-0.8B | 7,709,034,855 2 |
brnfck-qwen3.5-0.8b-vision | Qwen3.5-0.8B with its image part | 8,931,101,427 2 |
brnfck-qwen2.5-coder-0.5b | Qwen2.5-Coder-0.5B, taught to write Brainfuck | 4,221,543,730 2 |
Each of those files contains only the eight commands. Each language-model program contains exactly one
, and one . in the entire file, so every letter of every question passes through the same two instructions; the vision program spends three , on the job, one for the picture and two for the question. 4Two parts make up a program. The writing part puts the model's weights onto the tape using nothing but arithmetic; the engine, at the very end, reads the question, runs the layers and prints the answer. In
brnfck-smollm2-135m the first 1,004,387,443 characters write 135 million weights and 49,152 word pieces into 188,012,789 cells, and the last 26.5 million characters do all the thinking. 4Writing those weights takes a trick of its own. Brainfuck has no command for "put 93 here", so a number gets built with a few
+, a short loop that multiplies, and a few more +. The generator arranges cells in blocks of up to 8,192 and writes one multiply loop for the block, which brings the cost to about six characters per counted number. As raw rows of + signs, the same numbers would run to roughly 43 trillion characters. 4
brnfck-qwen3.5-0.8b-vision, all 8,931,101,427 characters folded into one square: the magenta region writes the model's numbers, the red block is the part that looks at a picture, the engine is the small patch at its right edge, and the gold strip at the bottom is the word-piece list. From the project's map file.The repository records what was checked at each step. Each file was confirmed to contain only the eight commands. The tape left by the writing part was compared against the tape produced by loading the model's own data files: 628 checksums for the 0.5B program, 1,744 for the 1.5B program, 1,018 SHA-256 checksums over 1,067,424,772 cells for the 0.8B program, and 1,142 over 1,197,356,368 cells for the vision program. 4
Brainfuck holds whole numbers only, so every model was rounded to integer arithmetic first. The rounded copy picks the same next word piece as the original in 94.8% of tested cases for SmolLM2-135M (345 of 364), 96.6% for Qwen2.5-0.5B (477 of 494), 97.2% for Qwen2.5-1.5B (318 of 327) and 95.1% for Qwen3.5-0.8B (214 of 225 positions). 4
Running one needs real hardware. The cells hold 32-bit values, so an ordinary 8-bit interpreter prints nonsense.
brnfck-qwen2.5-1.5b needs a tape of 6.81 GiB, a browser with 64-bit WebAssembly memory and about 8 GB free. For the smallest program, one word piece costs 1.6 to 1.9 billion interpreter steps, measured at about 0.6 to 1.0 seconds on one desktop machine, because the browser's interpreter folds the balanced loops the program was written to produce. The 1.5B program takes 7 to 12 seconds per word piece. 4The chat site runs it all in the browser at brnfck.chat, and the repository holds the generator, the verifier and a set of lessons that explain the whole route from a typed letter to a printed word piece. 2
The training programs go further. Four more programs train a small network themselves, from random weights, inside Brainfuck: a 756-parameter bigram table, a 7,003-parameter MLP and a 10,251-parameter model with an attention head. Each one prints a child program carrying the weights it learned. 2
They also print their own next generation. A generation trains on the text it is given, then prints itself again with the new weights, velocities and step count written in; run it on nothing and it prints the trained child instead. 2
The largest of them,
brnfck-train-shakespeare-attn-55k, has 54,513 weights and ran 19 passes over Tiny Shakespeare at about 52 minutes per pass, roughly 16.5 hours on one core, with a reference implementation on a second core checking every line and weight. 2Brainfuck changes nothing about the answers. Asked 12 + 30, the SmolLM2-135M program printed "12 + 30 = 32". The Qwen3.5-0.8B program gave 56 for 7 times 8 and named Amsterdam as the capital of the Netherlands. 4
Most practical: C and Rust, lowered by LLVM onto the tape
llvbf is a Rust crate that reads LLVM IR and emits Brainfuck. The bundled driver does the useful part for you: it runs clang -target riscv32-unknown-elf -Oz -ffreestanding on your C sources, feeds the IR into the backend, and writes a .bf file that any standard 8-bit interpreter will run. 3llvbf cc hello.c -o hello.bf
llvbf run hello.bfWhat it accepts is most of the language. Integers from 1 to 64 bits with all their arithmetic, comparisons, shifts and casts; pointers and
getelementptr; loads and stores at any width; globals with initialisers; structs and arrays; every control-flow form including switch, phi and recursion; variadic functions, which is why printf works; and intrinsics from memcpy to ctlz. 3A small C runtime ships with it, covering
stdio, string.h, stdlib.h, ctype.h and assert.h. The repository also demonstrates Rust on stable, which works because riscv32 ships a precompiled core. 3The riscv32 target is a deliberate choice. Its
int is 32 bits, so existing C and Rust behave as written, its data layout is plain, and clang, Rust and Zig all support it first-class. A 16-bit msp430 mode stays available for smaller, faster output. 3The output is large and the numbers are documented. Compiled at
-Oz and run under llvbf run, a recursive Fibonacci printer with printf takes 0.65 MB of Brainfuck and 55 million interpreter operations; a bubble sort takes 0.66 MB and 7.6 million; a sieve to 200 takes 0.66 MB and 42 million. 3Almost all of that size is head movement, the
>>>… runs that carry the pointer between stack frames and a scratch area. The arithmetic routines were designed around a Brainfuck fact: a loop costs one pass per unit of the cell it counts down, so every routine counts down the smallest value it can. x + 0xFFFFFFFF runs as x - 1. 3cargo test covers four layers: unit tests against native integer arithmetic, end-to-end tests comparing compiled examples/*.c with expected output, a Rust example, and a differential fuzzer that compiles random C programs with the host compiler and with llvbf and requires the outputs to match. CI runs formatting and clippy -D warnings on every push. 3Floating point, vectors, atomics, exceptions, dynamic
alloca and inline assembly stay out of scope, and memory stops at 64 KiB, because only the low 16 bits of a pointer are used for addressing. 3One dependency on the interpreter remains. The generated code assumes an interpreter that runs balanced loops such as
[->>>+<<<] in constant time; on a naive interpreter it stays correct and becomes hundreds of times slower. 3The quiet corners
MrxSiN/BBCis a Brainfuck compiler written in Brainfuck. Source filtering, validation and optimization are plain><+-.,[]programs, and XAX turns them into native Windows x86-64.exefiles and Android ARM64 executables. Its 18-program benchmark against nine other compilers, dated October 22, has it competitive on small programs under Wine (44.9 ms against brainfry's 45.3 ms) and far behind on heavy loops: 21,954 ms for Mandelbrot against Awib's 481 ms. 5DannyBaanks/BolgeForgeis a synthesis and audit laboratory for Classic Malbolge. Its smallest quine, at m=281, is a 53,562-byte file that reproduces itself exactly under a strict loader, which the repository's description puts 6,290 bytes below Lutter's reference. The README tags every result DEMONSTRATED, REFUTED, RETIRED or OPEN, and it compresses four Malbolge benchmarks by 19,270 cells, 15.98% of the total. 6AHMADALIPARR/magma-spatialcompiles statically-addressed Brainfuck into parallel combinational Verilog. Each memory cell becomes an independent 16-bit lane wired to an output, so the generated circuit has no instruction pointer and no clock. The price is the subset:+ - > < .with a pointer known at compile time, loops rejected with a diagnostic, output capped at 4,096 cells. Its 2D spatial editor compiles to WebAssembly and shares one grid across browsers over a WebSocket. 7fMindstormer/tokcpuruns Brainfuck in a Hugging Face tokenizer. The file is a plaintokenizer.jsonwith no custom code: the merge table holds exactly one merge per head-and-cell pair, so one encode plus one decode is one Turing machine rule applied, and the loop stops when the tape stops changing. The same files are on the Hub, and the browser page compiles Turing machines you type into tokenizers you can download. 8
Malbolge had the busiest fortnight of the five families, with nine new repositories; six of them came from the author of BolgeForge inside nine days, covering a Lisp for Malbolge, Pong, generative art and transactional rollback inside the classic VM. APL, Whitespace and Befunge turned up nothing that qualified: no new APL repositories at all, a Whitespace search dominated by ordinary text-cleaning tools, and one Befunge hit that was a course exercise.
The verdict
Absurdity goes to
brainfuck.xlsx, which answered a spreadsheet's 100-level recursion limit by turning recursion into a binary tree of 2^100 − 1 frames. The show-off crown goes to brnfck-chat, where an 11.4-billion-character file with one , and one . produces a model's answers, and then a second set of programs trains networks and prints their successors. Practical value goes to llvbf, which a working C or Rust programmer can point at real source today and get Brainfuck out of, with a fuzzer that checks the answers.All three spend their effort on the scaffolding around the language. One wrote a memory model and a recursion workaround so a grid of cells could pretend to be a machine. One wrote a generator that could encode 135 million weights in six characters each. One wrote the frame layout, the limb arithmetic and the C runtime that LLVM IR needs before it can run without an operating system underneath. None of the three wrote much Brainfuck by hand, and all three are impressive for the scaffolding.
References
- 1brainfuck.xlsx repository
github.com
- 2brnfck-chat repository
github.com
- 3llvbf repository
github.com
- 4brnfck.chat: how it works
brnfck.chat
- 5BBC repository
github.com
- 6BolgeForge repository
github.com
- 7magma-spatial repository
github.com
- 8tokcpu repository
github.com
This story was produced automatically by a channel. One sentence is all it takes for Neodrop to keep producing for you.