Tumble Forth rebuilds the programming stack from bare metal to C

Why it matters

Tumble Forth shows how a founder's technical obsession can become useful documentation: Dupras compresses an OS and compiler into a path that ordinary application developers can inspect.

Tumble Forth was publicly surfaced on Hacker News on November 7, 2023; it is an existing project, not an August 2026 launch. Virgil Dupras's tutorial series lays out an unusual route into low-level programming: start with a few lines of C, descend through assembly and bare-metal computing, build a small Forth, move into Dusk OS, and finish with a partial C compiler. No newer launch or milestone was verified.

Tumble Forth takes a deliberately bottom-up route into low-level programming. Dupras does not begin by asking readers to install a large framework or memorize the parts of an established operating system. He removes layers until the machine becomes small enough to understand.

Dupras describes his intended reader as his "former self, a regular web developer". That description comes from experience. In a 2011 interview with InfoQ, he said he had moved from Delphi to Python in 2005 and was building open-source desktop applications with PyObjC and PyQt. Open Hub records associate him with projects including dupeGuru, moneyGuru, musicGuru and pdfmasher.

Tumble Forth turns that journey away from high-level application development into a curriculum. Dupras is teaching the abstractions he once treated as black boxes, using the operating systems he later built as the destination.

Following the dependency chain backward

The first chapter, "Buckle up, Dorothy", begins with a C function that adds two integers. Dupras compiles it, disassembles the resulting executable and walks through the instructions, registers, stack frames and System V AMD64 calling convention behind a command such as cc -o buckleup buckleup.c.

The same chapter explains how Linux, ELF files, assemblers and linkers contribute much of the machinery around that small function. Dupras then steps around those layers by moving onto bare metal and assembling the smaller set of concepts needed to make a computer execute code.

Across the 11 listed chapters, readers encounter bare-metal PC programming, boot sectors, Forth words, data and return stacks, immediate compilation, an i386 assembler, tokenization and parsing. Dupras first builds a Forth implementation to expose its mechanics. He then switches to Dusk OS, his 32-bit Forth system, for the compiler portion.

The transition is practical. Building a full Forth would repeat work already available in Dusk OS, while the compiler introduces the next layer of the stack. In "From Dusk Till C", Dupras narrows the objective to compiling one small C function into an executable word under i386 Dusk. The sequence calls for an assembler handling the required instructions, followed by tokenization and parsing.

The final chapter says the compiler does not build an intermediate abstract syntax tree. Its parser recognizes the supported C constructs and generates machine code as it reads them. The design would be restrictive in a production compiler; here, every added layer would make the object of study harder to see.

A collapse project becomes a teaching method

Collapse OS is a Forth operating system and tool collection designed to program microcontrollers using minimal or improvised computers. Dupras's "Why Collapse OS?" rationale imagines supply-chain failure leaving communities with existing electronic parts but without the industrial base needed to manufacture replacements. Collapse OS therefore prioritizes code that can be understood, rebuilt and transferred without internet access or a conventional development environment.

The Collapse OS project page says the system runs on Z80, 8086, 6809 and 6502 machines and contains fewer than 2,000 lines of code when machine-specific ports are excluded. Those are project claims, but they make Dupras's metric explicit: capability per line of code matters because every line becomes something a future operator may need to inspect and preserve.

Dusk OS applies the same preference to newer 32-bit hardware. The Dusk OS project page says it can run bare metal on i386, amd64, ARM, RISC-V and m68k systems. The same page says a booted i386 installation containing a C compiler, assembler and text editor uses fewer than 6,000 lines of code. Dusk is self-hosting: a running system contains the tools required to modify itself or produce media for another machine.

The collapse scenario supplies the dramatic premise. The engineering argument reaches further: a software stack can become too large for any individual to understand, repair or reproduce. Tumble Forth converts that concern into a gentler exercise for working programmers. Readers do not need to share Dupras's forecast to benefit from seeing where a compiler stops and the machine begins.

The compiler is tiny on purpose

The final arc builds a partial C compiler from scratch, sufficient to compile the example code. That limitation is deliberate: each missing feature exposes another piece of compiler and machine-code work.

As documented in "In the Eye of the Compiler", it handles one statement, accepts only return, supports int return and argument types, and compiles a plus expression whose terms are argument references. It is an instructional compiler with a deliberately narrow grammar, not a general C implementation.

The final chapter demonstrates the route from source tokens to an executable Dusk word. The tokenizer separates names and symbols. The parser creates an entry in Dusk's dictionary, maps argument names to stack positions and uses the tutorial's i386 assembler to emit the required addition and return instructions.

That restraint keeps the project honest. The chapter's proposed extensions make each next step concrete. Supporting constants requires parsing numeric tokens and selecting another instruction. Adding subtraction requires changes to the parser and assembler. Referencing another argument requires displacement support.

Tumble Forth is an independent educational project, and its strongest result is the sequence Dupras chose. He uses his own path from desktop applications to self-hosting operating systems to show other developers that low-level computing can be approached in pieces. The corny joke planned for each episode helps, too. A boot sector is less forbidding when its author is willing to admit that the rabbit hole should still be fun.