Plain English

Plain English is an experimental programming language in which source code is written as ordinary English sentences, created by Gerry Rzeppa and his son Dan Rzeppa under the whimsical banner of the Osmosian Order of Plain English Programmers. It is best understood not as a mainstream tool but as a sustained experiment: an attempt to answer, with a working artifact, whether natural language can serve as real, compilable source code. Its most striking feature is that the entire system — a complete integrated development environment with its own compiler, editor, file manager, and page-layout tools — is itself written in Plain English, in roughly 25,000 sentences that ship with the download.

History & Origins

The project grew out of a personal frustration. Gerry Rzeppa, having programmed for many years in many languages, noticed that he habitually thought in English pseudo-code and then translated those thoughts into whatever artificial syntax he happened to be using. One day he asked the obvious question: why not simply code at the natural-language level and skip the translation step? He and his elder son, Dan, talked it over and decided to test the theory directly by building a compiler.

They wrote the first version over the winter of 2005–2006. The work was accompanied by a now widely circulated white paper, “Plain English Programming” (copyright 2006), published under the playful, quasi-monastic identity of the Osmosian Order, with Gerry styling himself the “Grand Negus” and Dan the “Prime Assembler.” The paper frames the whole endeavor around three questions:

1. Is programming actually easier when you do not have to translate natural-language thoughts into an alternate syntax?
2. Can natural languages be parsed in a deliberately “sloppy” way and still yield a stable, predictable programming environment?
3. Can low-level programs — like compilers themselves — be written in high-level, English-like languages?

Plain English exists to answer all three with a confident “yes,” backed by a self-hosting implementation rather than mere argument.

Note: some catalogs list this language’s origin as around 2000, but the creators’ own account places the first working compiler in the winter of 2005–2006, and the founding white paper is dated 2006. This page uses 2006 as the first-appearance year accordingly.

Design Philosophy

Plain English is built on a small set of strong convictions about how programming should feel:

• Code should read like prose. A program is a sequence of English sentences. Routines, conditions, and loops are expressed in words a non-programmer can follow, rather than in punctuation-heavy syntax.
• Sloppy parsing, precise meaning. The compiler tolerates a degree of arbitrary word choice and “noise” words, parsing input loosely — yet the sentences it actually acts on must still describe the program’s operation precisely. The slogan is essentially that the language is like pseudocode that compiles.
• The whole system should be comprehensible. Rather than hiding behind millions of lines of opaque tooling, the Osmosians made the entire environment small (a sub-megabyte download) and fully open in its own language, so a curious reader can study how a real compiler works by reading English.
• Simplicity over feature-completeness. Plain English deliberately omits much of the machinery of industrial languages. Its appeal is pedagogical and philosophical: it is a place to think clearly about what programming fundamentally requires.

What the Language Looks Like

In Plain English, you define data types (“things”), routines, and logic in full sentences. A routine to add two numbers and a typical call read close to how you might explain them aloud:

To add a number to another number giving a result:
Intel $8B85080000008B008B9D0C0000000301898500000000.

To run:
Start up.
Add 2 and 2 giving a count.
Write the count on the console.
Wait for the escape key.
Shut down.

Routines are written as English sentence templates — “To add a number to another number giving a result” — and later invoked by matching prose — “Add 2 and 2 giving a count.” Variables are introduced naturally (“a count”), and the standard library exposes I/O through readable verbs like “Write … on the console.” Where raw performance or hardware access is needed, the language allows inline machine code, illustrated above by the Intel directive carrying hexadecimal x86 bytes — a reminder that beneath the prose sits a genuine native-code compiler.

Key Features

• A self-hosting toolchain. The compiler, editor, file manager, hex dumper, linker, and WYSIWYG page-layout facility are all written in Plain English. The roughly 25,000-sentence source is included in the download, and the system can compile itself.
• Native-code generation. According to the community-maintained compiler’s documentation, it reads extension-less source files and produces 32-bit x86 Portable Executable files — actual native Windows programs, not interpreted bytecode.
• Windows targeting. The compiled programs use 8-bit ASCII and run on Windows systems; the toolchain is reportedly usable across a range of Windows versions, and the resulting programs are reported to run under WINE on other platforms. (Specific OS-version support is not fully documented in the project’s official materials.)
• A simple type system. Programmers define record-like aggregate types — the language’s “things” — and work with numbers, pointers, and text, keeping the model approachable for beginners.
• Inline assembly escape hatch. For low-level work, hexadecimal machine code can be embedded directly, which is how parts of the runtime and arithmetic primitives are implemented.
• Multilingual potential. The existence of Español Llano, a Spanish-language edition, demonstrates that the natural-language design generalizes beyond English.

Evolution

Plain English has always been a small, tightly held project rather than a fast-moving open ecosystem. After the original mid-2000s implementation and white paper, development continued in numbered builds of the Osmosian IDE. Version 4700 (CAL-4700) was released in January 2017, and in May 2018 the Order launched a blog, “The Journey Begins,” to republish its documentation and reach new readers.

Beyond the original authors, the language found a second life through a community “dynamic fork” hosted on GitHub by a developer using the handle “Folds” — syntax-compatible with CAL-4700, though not endorsed by the Osmosian Order. That fork began from version 3040 of the Osmosian IDE, folded in code from version 4700, and promoted build CAL-4018 to its master branch in March 2019, keeping the compiler buildable on contemporary Windows systems. This community stewardship — along with the Spanish-language edition — is how Plain English has remained runnable rather than becoming an abandoned curiosity.

Current Relevance

Plain English is not, and was never intended to be, a production language competing with Python or C. Its relevance is pedagogical and philosophical. It is one of the most concrete answers to a recurring dream in computing — that programs might one day be written in the language we already speak. By delivering a complete, self-hosting environment whose every component is written in readable English, the Osmosians turned a thought experiment into something you can download, read, and run.

It continues to surface in discussions of natural-language programming, beginner-friendly tooling, and the design of small self-hosting compilers — featured by outlets such as Hackaday and debated on forums like Hacker News and OSDev. Its presence on Rosetta Code, with solutions to classic tasks, lets curious readers compare its prose against conventional syntax directly.

Why It Matters

In an era now dominated by large language models that turn English instructions into code, Plain English stands out as a much earlier, hand-built attempt at the same goal — one that insists not merely on generating code from English, but on making the English be the code, deterministically and transparently. Whether or not one finds its “sloppy parsing” approach convincing, the project is a compelling demonstration that the boundary between human language and machine instruction is more negotiable than it first appears. As a small, complete, self-documenting system, Plain English remains a rewarding case study for anyone interested in language design, compiler construction, or the enduring question of how to make programming genuinely accessible.