Joy

Joy is the answer to a question almost nobody thought to ask: what if a functional language abandoned not just assignment but function application itself? Every mainstream functional language - Lisp, ML, Haskell - is built on applying functions to arguments, with the lambda calculus underneath. Joy, created by the Australian philosopher Manfred von Thun at La Trobe University in Melbourne, is instead built on the composition of functions. Every Joy program denotes a function that takes a stack and returns a stack, and writing two programs next to each other composes them. There are no formal parameters, no named variables, no lambdas - just words, quotations, and the algebra that connects them. Made public in 2001, Joy never sought industrial adoption, but it founded an entire family of languages - the concatenative languages - and gave the stack machine, long the pragmatic engine room of Forth and the JVM, a clean mathematical semantics.

History and origins

Joy’s creator was not a computer scientist by training. Manfred von Thun (1934-2011) joined the philosophy department of La Trobe University in 1972 and taught there until his retirement; his doctorate was in inductive logic and logical probability, and his teaching ran to deductive logic, philosophy of science, and cybernetics. He began programming in 1978, in Pascal on a DEC-10, and around the early 1980s encountered the paper that set the course of the next two decades: John Backus’s 1977 ACM Turing Award lecture, “Can Programming Be Liberated from the von Neumann Style?”, with its call for variable-free, function-level programming and an algebra of programs.

Von Thun’s route to Joy ran through philosophy’s own toolkit. Through the 1980s he experimented - in Prolog - with a logic-programming language grounded in the combinatory logic of Schönfinkel and Curry, Quine’s predicate functors, and Tarski’s cylindric algebras: systems that all eliminate bound variables. The decisive move, as he later told an interviewer, was restricting the language’s binary relations to unary functions - at which point relational composition collapsed into function composition, and the shape of Joy appeared. A stack emerged as the practical way for such functions to handle multiple values, and in 1995 he began writing the C interpreter that became Joy.

The language reached the world in 2001. Von Thun published a remarkable suite of tutorials and papers on his La Trobe website - an entire self-contained literature covering the language, its algebra, and its mathematical foundations - while John Cowan contributed floating-point support and other improvements to the interpreter early that year. In November 2001 the paper “Joy: Forth’s Functional Cousin” was presented at the 17th EuroForth conference at Schloss Dagstuhl by Reuben Thomas on von Thun’s behalf, introducing Joy to the community whose language it most resembled on the surface. The final release of von Thun’s own interpreter is dated March 17, 2003.

Design philosophy: composition, not application

The whole of Joy follows from one identity, which von Thun stated in nearly every paper: the concatenation of two programs denotes the composition of the functions denoted by the two programs. In an applicative language, f(g(x)) applies functions to values. In Joy, the same computation is written g f - and that juxtaposition is the composition. Because every program, from a single literal to the whole system, denotes a function from stacks to stacks, programs compose as freely as text concatenates:

• Literals are functions too. The numeral 5 is not a value but the function that pushes 5 onto the stack. [1 2 3] pushes a list. Uniformity is total.
• No variables, no environments. Since nothing is ever named, there is no substitution, no scope, no capture - the machinery that makes lambda calculus subtle simply is not present.
• Quotations are first-class programs. Wrapping a program in square brackets - [dup *] - pushes it onto the stack as inert data, a list that can be built, taken apart, or handed to a combinator that executes it.
• Combinators replace control structures. i executes a quotation; ifte chooses between two; map, filter, and fold run one over a list; primrec and linrec package recursion schemes so that even recursion needs no named function - a role played in lambda-calculus languages by fixpoint operators like the Y combinator.

The result is a language in which reasoning about programs is rewriting: 2 3 + can be replaced by 5 anywhere it appears, and algebraic laws - for instance, that mapping a composed function equals composing two maps - are usable identities between program texts, not metatheory. This was precisely the “algebra of programs” Backus had asked for, arrived at by a philosopher who took the algebra seriously first and derived the language from it.

What Joy looks like

A definition and its use, from von Thun’s tutorial material:

DEFINE square == dup * .

5 square            (* leaves 25 on the stack *)

dup duplicates the top of the stack and * multiplies the top two elements, so dup * is the squaring function - defined without ever naming an argument.

Combinators make list processing read like algebra:

[1 2 3 4] [dup *] map      (* [1 4 9 16] *)
[1 2 3 4 5] [odd] filter   (* [1 3 5]    *)

And recursion arrives without self-reference. The primrec combinator takes a value and two quotations - one for the base case, one to combine - so the factorial function is simply:

5 [1] [*] primrec          (* 120 *)

primrec unfolds 5 into 5 4 3 2 1, starts from the base value 1, and folds with *. The equivalent lambda-calculus definition needs a bound variable and a fixpoint; Joy needs four symbols.

Forth’s functional cousin

Joy looks strikingly like Forth - postfix notation, a stack, small composable words - and von Thun happily adopted the EuroForth paper’s framing of the two as cousins. But the resemblance was convergent evolution, not descent. Forth is imperative: its words are procedures that mutate a stack in place, and its semantics are operational. Joy is purely functional: its words denote functions, the stack is conceptually a value passed from function to function, and its semantics are equational. The load-bearing difference is the quotation - a program as a first-class, inspectable value - together with the combinators that animate it, giving Joy the higher-order character that Forth approximates only through execution tokens. Von Thun credited Forth’s implementation culture as an inspiration while insisting on the distinction in kind.

Evolution and implementations

Joy was a one-professor research project, and its artifact history is correspondingly compact. The lineage runs from joy0, the original minimal interpreter, through joy1, the elaborated C implementation with its substantial standard library of list, aggregate, and recursion combinators. John Cowan’s contributions in 2001 modernized the interpreter, and von Thun’s final release came in March 2003, after which his attention - as he described in the 2003 interview published on nsl.com and in Vector - had turned to libraries for specialized data structures.

After von Thun’s death on October 23, 2011, his La Trobe pages eventually vanished, and the community stepped in. Kevin Albrecht’s joy-mirror and other mirrors preserve the complete papers and tutorials; the joy0 and joy1 sources are curated on GitHub (the Wodan58 repositories) explicitly as reference implementations; and Thun, Simon Forman’s Joypy project, reimplements the language in Python with documentation, a REPL, and experiments in type inference and compilation. Ports and reimplementations in other languages appear regularly - Joy’s tiny core makes it a beloved weekend-implementation target.

Current relevance

Joy is dormant and has been since the mid-2000s: there is no standard, no package ecosystem, and no active evolution of the language itself. Its status today is that of a foundational text that happens to execute. Running Joy in 2026 means building the preserved C sources from GitHub or installing Thun - both modest undertakings - and the mirrored papers remain the canonical way in. Where Joy is genuinely alive is downstream: Factor, begun by Slava Pestov in 2003, built a practical, batteries-included concatenative language on ideas Joy pioneered; Cat explored static typing for the paradigm; and the concatenative.org community continues to treat von Thun’s papers as the family’s founding documents.

Why it matters

It completed Backus’s program. Backus’s Turing lecture demanded function-level programming with a usable algebra of programs; FP itself never became runnable practice. Joy is arguably the most direct realization of that demand - a language where equational reasoning about program text is not a proof technique but the ordinary way of working.

It named and founded a paradigm. Before Joy, stack languages were understood operationally, as machines. Joy’s semantics - concatenation as composition - revealed the denotational structure underneath, and the community that formed around it adopted the term concatenative for the family. Every subsequent language in that family, from Factor onward, descends from this reframing.

It is a masterclass in smallness. One identity, a handful of combinators, and no binding constructs generate a complete, higher-order, purely functional language. For students of language design, Joy is one of the clearest demonstrations on record that a language’s power can come from what it removes.

It bridged philosophy and computing. Joy was derived from Quine, Schönfinkel, Curry, and Tarski by a philosophy professor working alone - a reminder, increasingly rare in the industrial era of language design, that programming languages are formal philosophy with an interpreter attached.