Context
A microworld at the AI Lab
SHRDLU was the showpiece of the microworlds programme run by Marvin Minsky and Seymour Papert, Winograd's doctoral advisor. The wager: master a small closed world completely, then scale up.
MacLisp · Micro-Planner · MIT AI Lab, 1968–70
Reading the code at the high-water mark of symbolic AI
A critical code study of Terry Winograd's natural-language-understanding program and its tabletop blocks world, read as a cultural text.
SHRDLU is where code first appears to understand. Written across 1968–70 by Terry Winograd at the MIT Artificial Intelligence Laboratory, it let a person type ordinary English commands and questions, and watch a simulated arm rearrange coloured blocks and pyramids on a screen in answer. Ask it to pick up a big red block and it does; ask why it did something and it tells you. For a moment in the early 1970s it seemed that the problem of machine understanding had been opened.
This project reads that program as a cultural text. Following Critical Code Studies, the source is approached in its multiplicity, as language, as mechanism, as a model of a world, and as a repository of the assumptions of the artificial-intelligence programme that produced it. Reading about the history of AI is not the same as reading its code. The aim is to do the latter: to sit with the MacLisp and the Micro-Planner, the grammar written as procedures, the hand-built microworld, and the famous scripted dialogue, and to ask what this code knows, what it only appears to know, and what its founding demonstration leaves out.
Critical Code Studies (CCS) applies the interpretive methods of the humanities to computer source code, reading code, architecture, and documentation within their sociohistorical context. Its premise is that lines of code are not value-neutral: meaning grows out of what the code does but is never exhausted by it. Code can be close-read like any other text, attended to for its naming, its comments, its silences, and the assumptions it encodes, while still being held to its material test, that it must compile and run.
This reading works in the tradition developed by Mark C. Marino1 and David M. Berry2, reading code at once as language, mechanism, world-model, and social repository. SHRDLU is an unusually rich object for this method, because its central claim was itself a claim about meaning: that to represent knowledge as procedures was to let a machine understand.
1 Mark C. Marino, Critical Code Studies (Cambridge, MA: MIT Press, 2020), the field's book-length statement, following his founding essay of the same title (Electronic Book Review, 2006). ↩
2 David M. Berry, The Philosophy of Software: Code and Mediation in the Digital Age (Basingstoke: Palgrave Macmillan, 2011); and, for the collaborative method applied to a contemporary of SHRDLU, David M. Berry and Mark C. Marino, "Reading ELIZA: Critical Code Studies in Action" (Electronic Book Review, 2024). ↩
This study sits alongside the team's critical code readings of the other founding programs of the long 1960s, among them Joseph Weizenbaum's ELIZA (1966) and the MIT Spacewar! (1962). Three programs, three claims about what a computer could be made to do: ELIZA teaches the machine to talk, Spacewar! teaches it to play, and SHRDLU teaches it to understand. Read together through their source, they let us approach the origins of computational culture not through its myths but through its code, and to see how early and how confidently the claim of machine understanding was made.
We are once again surrounded by machines that appear to understand language. The large language models of the 2020s answer in fluent prose across an open domain, where SHRDLU could converse only about a tabletop of blocks. Yet the two stand in an instructive symmetry. SHRDLU's understanding was grounded, every word tied to procedures over a world it could inspect and act on, and it could explain its reasoning step by step, but it could not leave its microworld. Today's models are general but, in the classic phrase, arguably ungrounded: fluent everywhere, anchored nowhere, and opaque as to why they say what they say.
Reading SHRDLU's code returns us to the first, most optimistic version of the dream, and to the moment its limits became visible. The history of that disappointment, the move from microworld to scaling problem to "AI winter", is also the prehistory of the present.
SHRDLU's world was a simulated tabletop, the paradigmatic "microworld" of the Minsky–Papert research programme: a box, a table, and a handful of blocks, cubes and pyramids in red, green and blue, moved by a simulated arm. The system was built from four parts, all in MacLisp under the ITS operating system: a parser; a grammar of English written as procedures (Winograd's PROGRAMMAR, after Halliday's systemic grammar); programs for semantic analysis; and a deductive problem-solver in Micro-Planner. The conversation here is the demonstration dialogue Winograd published, reproduced from his own transcript and running on those parts: the person types in lower case, SHRDLU answers in capitals.
SHRDLU ran on the MIT AI Lab's DEC PDP-6, with the blocks world drawn as line graphics on a DEC Type 340 display attached to it; the conversation itself was carried on a teletype. The program was written in MacLisp, the lab's Lisp dialect, under the Incompatible Timesharing System (ITS), with its deductive reasoning expressed in Micro-Planner, a practical subset of Carl Hewitt's Planner implemented at the lab by Gerald Sussman, Winograd and Eugene Charniak.
The world it modelled was deliberately tiny. A microworld in the Minsky–Papert sense is small enough that all the relevant knowledge can be hand-built into the program: a closed domain of a few solids and the relations "on", "in", "supports", "bigger than". That smallness is the condition of SHRDLU's apparent fluency.
That wager has lately returned. After the success of large language models and diffusion models, much of contemporary AI has turned to world models: the argument, pressed by Yann LeCun in his work on predictive world models (his JEPA programme) and by Fei-Fei Li under the name "spatial intelligence", that an agent which acts in the world needs an internal model of it, and not only a facility with text or images. SHRDLU is an early, miniature instance of exactly that idea, a program that kept and reasoned over a model of its world, which is why its microworld is worth reading closely now rather than only as history. The overview follows that thread to the philosophical question it raises.
Context
SHRDLU was the showpiece of the microworlds programme run by Marvin Minsky and Seymour Papert, Winograd's doctoral advisor. The wager: master a small closed world completely, then scale up.
Method
Winograd's thesis was that knowledge, grammar included, is best represented as procedures. His parser PROGRAMMAR expressed the rules of English as little programs, drawing on M. A. K. Halliday's systemic grammar.
Artefact
Because its actions were driven by a Micro-Planner goal stack, SHRDLU could be asked "why?" and trace its own reasoning back, command by command, to "because you asked me to". An early, readable model of machine self-explanation.
Approach
We read the surviving source across the registers of CCS, and treat programming as scholarship, drawing on the preserved code and modern reconstructions so interpretation is tested against the artefact.
The study works across the registers of Critical Code Studies, pairing close technical explication of a code fragment with the cultural constellation that spirals out from it.
The full conversation Winograd published, forty-two exchanges from "pick up a big red block" to "you're welcome", reproduced verbatim with its original typos and read closely.
▶ Enter the dialogueSee the full bibliography for more readings.
With grateful acknowledgement to Terry Winograd, whose own SHRDLU pages preserve the source code, the demonstration dialogue, and the story of the program's name, on which this project draws.
The SHRDLU reading is a Critical Code Studies project. Correspondence and corrections are welcome.
The CCS Working Group
github.com/critical-code-studies