Konrad Zuse and Plankalkül: A Programming Language Designed Before Electronic Stored-Program Computers
Konrad Zuse designed Plankalkül during and immediately after the Second World War as a notation for expressing general computational plans, decades before the language was fully published or implemented.
Programming languages were imaginable before they were practical
Konrad Zuse is usually introduced through the Z1 and Z3 computers, but his most forward-looking software contribution was a language design rather than a machine. During the final years of the Second World War and the difficult period immediately afterward, he developed a notation he called Plankalkül, roughly “plan calculus.” The Computer History Museum places this work in the mid-1940s and describes it as an early attempt to formulate algorithms independently from the details of one machine.[1]
That chronology is remarkable because electronic stored-program computers had not yet become practical systems. Programming was not an established profession with agreed terminology, standard languages or compiler theory. Zuse nevertheless tried to describe computation with variables, logical conditions, structured values and repeated operations. The ambition was not simply to invent shorter symbols for machine instructions, but to give algorithms a notation of their own.
Plankalkül was separate from the Z3’s machine code
Zuse’s wartime machines executed programs through machine-specific mechanisms such as punched film. Plankalkül should not be described as an assembler for the Z3. It was a later and more abstract conceptual layer intended to express general computational plans.
Zuse treated programs as formal plans
A 1948 manuscript preserved in the Konrad Zuse Internet Archive is titled “Über den Allgemeinen Plankalkül als Mittel zur Formulierung schematisch-kombinativer Aufgaben,” explicitly presenting the notation as a general means for formulating schematic and combinatorial tasks.[2] The language was meant to organize operations on values into plans and subplans rather than force every algorithm into the raw instruction format of one machine.
This framing matters because it anticipates a central idea of programming-language design: a program can have a structure that is meaningful to humans and mathematical reasoning even when the eventual machine representation is different. The language could describe the shape of information and the relationships among operations rather than making storage locations the primary vocabulary.
Structured data appeared surprisingly early
Later reconstructions of Plankalkül emphasize its ability to work with typed values, arrays and compound structures assembled from simpler values. The notation looks unfamiliar today, but the design problem is familiar: how should a program represent a collection of related data without reducing every concept to an undifferentiated machine word?
Control flow was expressed above raw instructions
Plankalkül included assignment-like operations, conditional execution and repetition. The Freie Universität Berlin team that later implemented the language highlighted variables, structured values, assignments, conditionals and loops among the concepts already present in Zuse’s design.[5]
These features do not make Plankalkül identical to a modern structured language. Its notation used multi-line arrangements and conventions that differ sharply from the linear source text that later became standard. The historical importance is the level of abstraction: Zuse was describing decisions and iterations as programming constructs while practical programmers elsewhere were still learning how to organize instruction sequences for individual machines.
Chess exposed the need for richer program structure
Zuse used chess-related examples to demonstrate the notation. A chess position requires representations for pieces, locations, legal moves and conditional rules, making it a more demanding test of a language than a simple arithmetic formula.
Isolation limited contemporary influence
Plankalkül developed largely outside the Anglo-American programming communities that formed around EDSAC, Manchester machines, UNIVAC and IBM systems. The surviving 1948 manuscript proves that the ideas existed, but the language did not become a common implementation platform for the first generation of postwar programmers.[2]
This distinction prevents a common historical mistake. An invention can be early without being the direct ancestor of later systems. FORTRAN, ALGOL and other influential languages emerged from different teams and practical needs, often without knowledge of Zuse’s unpublished work.
Priority is not the same as lineage
Plankalkül can legitimately be discussed as an exceptionally early high-level algorithmic language design without claiming that later mainstream languages copied it. Chronological priority and historical influence are separate questions.
Publication came decades after the original design
Zuse’s fuller treatment, Der Plankalkül, appeared in 1972. The Konrad Zuse Internet Archive preserves the lengthy publication, which arrived after high-level programming had already been transformed by FORTRAN, COBOL, ALGOL, Lisp and many other languages.[3]
The delay explains the language’s paradoxical place in history. Many of its concepts look advanced when compared with the date of conception, yet they did not shape the daily practice of programmers during the period when language standards and compiler techniques were first becoming institutionalized.
Historians reconstructed Plankalkül as a language ancestor
Friedrich L. Bauer and Hans Wössner’s 1972 essay described Plankalkül as a forerunner of contemporary programming languages and helped bring the notation into the historical literature of programming rather than leaving it as a footnote to Zuse’s hardware work.[4]
That retrospective attention also made it possible to compare the language more precisely with later systems. The comparison is most useful when it respects differences. Plankalkül had distinctive notation, unusual conventions and no mature compiler ecosystem. Its value is not that it secretly contained every later language, but that it tackled many of the same abstraction problems before the field had standard answers.
A working implementation arrived around the turn of the millennium
In 2000, researchers at Freie Universität Berlin announced an implementation of Plankalkül together with a linearized notation suitable for modern software tooling.[5] The project did not retroactively turn Plankalkül into a practical 1940s programming system. Instead, it demonstrated that the surviving design was coherent enough to be interpreted as an executable language.
The enormous gap between design, publication and implementation is historically valuable because it separates events that are often collapsed together. Conceiving a language, communicating it to a community and building reliable tools for it are distinct achievements.
Why Plankalkül belongs at the beginning of programming-language history
Plankalkül shows that abstraction in programming did not have to wait for a mature software industry. Zuse was already trying to express algorithms in terms of variables, structures, logic and reusable plans while the practical machinery of electronic stored-program computing was still emerging.[1][4]
Its contemporary influence was limited by isolation and delayed publication, so it should not be used to erase the independent work of later language designers. Its importance is different: it demonstrates how early the idea of programming above the machine could be conceived. That makes Plankalkül a crucial reminder that the history of software includes designs whose intellectual timing was far ahead of their opportunity for adoption.
Works Cited
- 01Computer History Museum — Timeline of Computer History: Software & Languages computerhistory.org
- 02
- 03
- 04
- 05
CodeHistory is a living archive. Citations document the evidence used for this edition; later evidence may refine the account.
Submit a research lead