# INTERCAL
**INTERCAL**, short for *Compiler Language With No Pronounceable Acronym*, is a parody programming language designed on the morning of May 26, 1972 by Donald R. Woods and James M. Lyon at Princeton University[1](https://forstinea.nl/documents/INTERCAL%20revised%20reference%20manual.pdf). Its stated ambition was to have a compiler language with nothing at all in common with any other major language of the day, such as FORTRAN, BASIC, COBOL, ALGOL, APL, LISP, and PL/I; it kept only basic elements like variables, arrays, and I/O, and rejected every conventional operation[1](https://forstinea.nl/documents/INTERCAL%20revised%20reference%20manual.pdf). It is generally regarded as the original [esoteric programming language](https://www.edgepedia.org/esoteric-programming-language), and later esolangs share its playful, satirical stance toward conventional language design[2](https://arxiv.org/abs/2505.15327).
| Key fact | Detail |
|---|---|
| Full name | Compiler Language With No Pronounceable Acronym[3](https://hopl.info/showlanguage2.prx?exp=585) |
| Designed | Morning of May 26, 1972, by Donald R. Woods and James M. Lyon at Princeton University[1](https://forstinea.nl/documents/INTERCAL%20revised%20reference%20manual.pdf) |
| First implementation | INTERCAL-72 compiler written in SPITBOL for the IBM/360, using the EBCDIC character set[1](https://forstinea.nl/documents/INTERCAL%20revised%20reference%20manual.pdf) • [3](https://hopl.info/showlanguage2.prx?exp=585) |
| Politeness rule | Fewer than 1/5 of statements carrying PLEASE means rejection as insufficiently polite; more than 1/3 means rejection as excessively polite[1](https://forstinea.nl/documents/INTERCAL%20revised%20reference%20manual.pdf) |
| Signature statement | COME FROM, added in C-INTERCAL, based on R. L. Clark's 1984 April Fools paper in Communications of the ACM[1](https://forstinea.nl/documents/INTERCAL%20revised%20reference%20manual.pdf) |
| Operators | Mingle (Princeton ¢, Atari $) and select; binary operators written as ampersand (&) for AND, V for OR, and a backspaced "bookworm" or ? for exclusive-or[4](https://www.catb.org/~esr/intercal/ick.htm) |
| Modern implementations | C-INTERCAL (Eric S. Raymond, 1991), CLC-INTERCAL, J-INTERCAL, the Rust-based Rick, and INTERCAL-64[3](https://hopl.info/showlanguage2.prx?exp=585) • [5](https://github.com/birkenfeld/rick) • [6](https://github.com/PLEASE-ABSTAIN/INTERCAL64) |
## Origin and purpose
The language was, in the words of one early account, "not so much designed as perpetrated" at Princeton on the morning of May 26, 1972[7](https://www.catb.org/~esr/intercal/stross.html). The manual itself explains the goal: to build a compiler language sharing nothing with any major language the authors knew. For the most part it stayed true to that goal, keeping only variables, arrays, and the ability to do I/O while eschewing all conventional operations[1](https://forstinea.nl/documents/INTERCAL%20revised%20reference%20manual.pdf). A later survey calls it "the longest-running and most convoluted joke in the history of programming language design" and notes that although the language initially had a minimal compiler and a negligible body of source code, it attracted dedicated enthusiasts, including [Eric S. Raymond](https://www.edgepedia.org/eric-s-raymond) and [Donald Knuth](https://www.edgepedia.org/donald-knuth), who helped popularize it[2](https://arxiv.org/abs/2505.15327).
The original Princeton compiler was written in SPITBOL, a variant of SNOBOL, and compiled in two stages: INTERCAL source was first converted into SPITBOL source, which was then compiled[1](https://forstinea.nl/documents/INTERCAL%20revised%20reference%20manual.pdf). The compiler was never widely circulated, and the original source code remained lost for decades until it was recovered and published[8](https://www.catb.org/esr/intercal/).
## Language features
An INTERCAL program is a list of statements, each consisting of an optional line label, a statement identifier, an optional execution chance, the statement itself, and optionally ONCE or AGAIN[4](https://www.catb.org/~esr/intercal/ick.htm). Every statement begins with an identifier: DO, PLEASE, or PLEASE DO[9](https://podscripts.co/podcasts/future-of-coding/intercal-by-donald-woods-james-lyon).
**Politeness.** A feature of INTERCAL-72 not documented in the original manual was a required level of politesse. If fewer than one fifth of the program's statements included the PLEASE qualifier, the program was rejected as insufficiently polite; if more than one third included it, the program was rejected as excessively polite[1](https://forstinea.nl/documents/INTERCAL%20revised%20reference%20manual.pdf). C-INTERCAL implements this check, and the intercal.el editor mode shipped with the distribution randomly expands "do " to "PLEASE DO" one quarter of the time to help programmers cope[1](https://forstinea.nl/documents/INTERCAL%20revised%20reference%20manual.pdf).
**Operators.** INTERCAL's binary operations include unconventional ones such as bitwise interleaving of values, which makes ordinary arithmetic complex and convoluted[2](https://arxiv.org/abs/2505.15327). The mingle operator is written as a cent sign, called "change", in the original Princeton syntax, and as the "big money" character $ in the Atari syntax; the exclusive-or operator was written in Princeton INTERCAL-72 as a "bookworm", a V overprinted with a hyphen via backspace, a combination that causes problems on some systems, which was probably the original intention[4](https://www.catb.org/~esr/intercal/ick.htm). AND and OR are written with the ampersand (&) and the letter V respectively[4](https://www.catb.org/~esr/intercal/ick.htm).
**Control flow.** Statements normally run in sequence, but many situations can change this, including the NEXT statement, whose return-address stack is limited to 80 locations by all known INTERCAL compilers, a limit said to discourage NEXT-stack leaks[4](https://www.catb.org/~esr/intercal/ick.htm). Statements can also carry an execution chance written as %n, the percentage probability that the statement executes, and can be negated with NOT or N'T[7](https://www.catb.org/~esr/intercal/stross.html).
**COME FROM.** The best-known INTERCAL addition is the COME FROM statement, which lets control arrive at a labeled point from elsewhere in the program, dispensing with GOTO while preserving the pleasures of self-modifying control flow[7](https://www.catb.org/~esr/intercal/stross.html). The earliest known description of COME FROM in the computing literature is R. L. Clark, "A linguistic contribution to GOTO-less programming," *Communications of the ACM* 27 (1984), pp. 349-350, part of the famous April Fools issue; since language designers' subsequent rush to adopt it was nonexistent, it was decided COME FROM belonged in C-INTERCAL[1](https://forstinea.nl/documents/INTERCAL%20revised%20reference%20manual.pdf).
**Number formats.** In keeping with the language's contrarian character, C-INTERCAL outputs numbers in [Roman numerals](https://www.edgepedia.org/roman-numerals) by default, and a runtime "wimpmode" option, off by default, lets the user choose conventional notation after being subjected to a humiliating message about what a wimp he or she is[1](https://forstinea.nl/documents/INTERCAL%20revised%20reference%20manual.pdf).
## Implementations and syntax history
The history of the language is, in its own manual's words, plagued with multiple syntaxes and character sets[4](https://www.catb.org/~esr/intercal/ick.htm). The Princeton compiler used EBCDIC; an uncompleted Atari implementation, pre-described in 1982 additions to the original manual, substituted ASCII and replaced the cent sign with $ because ASCII has no "change" sign[1](https://forstinea.nl/documents/INTERCAL%20revised%20reference%20manual.pdf) • [4](https://www.catb.org/~esr/intercal/ick.htm). Two syntax families survive: the original Princeton syntax, considered the official one and the default in CLC-INTERCAL, and the Atari syntax, used by C-INTERCAL and J-INTERCAL and most common for exchanging programs on Usenet because it relies on plain ASCII[4](https://www.catb.org/~esr/intercal/ick.htm).
Eighteen years after the original, Eric S. Raymond, a programmer and author of *The New Hacker's Dictionary*, perpetrated a UNIX-hosted INTERCAL compiler as a weekend hack; C-INTERCAL uses C as an intermediate language and has since been maintained and extended by an international community, including Louis Howell, Steve Swales, Michael Ernst, and Brian Raiter[1](https://forstinea.nl/documents/INTERCAL%20revised%20reference%20manual.pdf) • [7](https://www.catb.org/~esr/intercal/stross.html). Its later versions added COME FROM and multilingual support including Basque, Nahuatl, Sanskrit, and Tagalog, and version 0.18 and later are localized for Ancient Roman, accepting Latin-language keywords as equivalents for the English ones[3](https://hopl.info/showlanguage2.prx?exp=585) • [1](https://forstinea.nl/documents/INTERCAL%20revised%20reference%20manual.pdf). CLC-INTERCAL extends the Princeton syntax to modern features, and Threaded INTERCAL, created by Malcom Ryan as a modified C-INTERCAL, implemented COME FROM-based multithreading[4](https://www.catb.org/~esr/intercal/ick.htm).
More recent implementations include Rick, a Rust interpreter and compiler modeled closely on C-INTERCAL, which implements the base INTERCAL-72 language plus COME FROM, computed COME FROM, TRY AGAIN, computed ABSTAIN, and binary array I/O; its interpreter parses source into what it calls an AST, an "abstract sadist tree", and runs about 10 times slower than its compiled mode, which translates to Rust[5](https://github.com/birkenfeld/rick). INTERCAL-64, a .NET-based compiler called churn, extends the language with 64-bit arithmetic, a pure-INTERCAL system library, and a DAP debugger for VS Code[6](https://github.com/PLEASE-ABSTAIN/INTERCAL64). The language is packaged in mainstream distributions: Debian ships both the intercal and clc-intercal compiler packages[10](https://packages.debian.org/intercal), and it can be installed with brew on macOS or apt on Ubuntu[2](https://arxiv.org/abs/2505.15327).
## Place in programming language culture
INTERCAL is considered the archetypal esolang, demonstrating the genre's foundational principles of syntactic absurdity and satire toward conventional language design[2](https://arxiv.org/abs/2505.15327). Scholars of esoteric languages identify its philosophy as "technomasochism", since programmers appear to derive pleasure from a painful development experience[2](https://arxiv.org/abs/2505.15327). A chapter in *Software Studies: A Lexicon* groups it with parody languages that comment on the features of traditional languages such as FORTRAN and COBOL, and contrasts it with [Malbolge](https://www.edgepedia.org/malbolge), a later language designed specifically to be difficult to program in rather than merely to share nothing with other languages[11](https://sidoli.w.waseda.jp/Mateas_2006_Weird_Languages.pdf).
Practical use is rare but not absent. Documented INTERCAL projects include mathematics programs, a quine, and a CGI script that took the language onto the web[12](https://stackoverflow.com/questions/33824200/are-there-any-real-world-applications-written-in-intercal). A 2025 academic essay argues that even joke languages like INTERCAL deserve serious study, because working within their self-imposed constraints can improve general programming-language awareness and sharpen thinking about language design[2](https://arxiv.org/abs/2505.15327).
## References
1. [Donald R. Woods and James M. Lyon, *The INTERCAL Programming Language Revised Reference Manual* (with C-INTERCAL revisions by Louis Howell and Eric S. Raymond)](https://forstinea.nl/documents/INTERCAL%20revised%20reference%20manual.pdf)
2. [Jeremy Singer and Steve Draper (2025). Let's Take Esoteric Programming Languages Seriously. Onward! '25, ACM.](https://arxiv.org/abs/2505.15327)
3. [INTERCAL (ID:585/int010), Online Historical Encyclopaedia of Programming Languages (HOPL)](https://hopl.info/showlanguage2.prx?exp=585)
4. [C-INTERCAL 0.29 Revamped Instruction Manual](https://www.catb.org/~esr/intercal/ick.htm)
5. [Rick: INTERCAL interpreter/compiler in Rust, GitHub](https://github.com/birkenfeld/rick)
6. [INTERCAL-64: a 64-bit INTERCAL compiler and runtime, GitHub](https://github.com/PLEASE-ABSTAIN/INTERCAL64)
7. [Charles Stross (1992). INTERCAL -- the Language From Hell.](https://www.catb.org/~esr/intercal/stross.html)
8. [The INTERCAL Resources Page](https://www.catb.org/esr/intercal/)
9. [Future of Coding podcast: INTERCAL by Donald Woods & James Lyon, transcript](https://podscripts.co/podcasts/future-of-coding/intercal-by-donald-woods-james-lyon)
10. [Debian package search: intercal](https://packages.debian.org/intercal)
11. [Michael Mateas (2006). Weird Languages. In *Software Studies: A Lexicon*, MIT Press.](https://sidoli.w.waseda.jp/Mateas_2006_Weird_Languages.pdf)
12. [Are there any real world applications written in INTERCAL? Stack Overflow](https://stackoverflow.com/questions/33824200/are-there-any-real-world-applications-written-in-intercal)
---
*Topic: Encyclopedia › Technology and the built world › Computing and digital systems › Software and programming › Programming languages › Individual programming languages › C-family and imperative languages*
*Initially written Sep 17, 2026 · Reviewed: Oct 15, 2026 · Edited: Oct 15, 2026 · Last review: Oct 15, 2026*
*Copyright 2026 EdgeChat AI, a subsidiary of Biostate AI.*
License: Edgepedia Community License 1.0, https://www.edgepedia.org/edgepedia/license