Revisiting SHRDLU: The Technical Lineage and Modern Value of Procedural Semantics

A Classic Question from Reddit

Recently, a developer on Reddit posed a question that was equal parts nostalgic and practically relevant: Are there currently active, rule-based open-source projects built on procedural semantics? The poster specifically called out the classic system SHRDLU, looking for natural language systems that use hand-crafted rules to handle queries, commands, and narrative interaction.

The key emphasis was that these rules should take a procedural form — that is, execution logic resembling a programming language, rather than declarative knowledge representation. This seemingly niche technical question actually touches on a thread in NLP history that has been largely obscured by the wave of large language models.

What Is Procedural Semantics?

Starting with SHRDLU

To understand the question, we need to go back to the 1970s. SHRDLU was a classic natural language understanding system developed by Terry Winograd at MIT. It could understand and execute English commands within a virtual "blocks world" — for example, "Put the red block on top of the green cube."

SHRDLU was written entirely in Lisp, and its procedural semantics relied on an elegant interpreter mechanism: after decomposing an English sentence into a parse tree, each syntactic structure corresponded to a fragment of Lisp code, making the parsing process itself an act of program execution. This design allowed SHRDLU to handle complex linguistic phenomena such as anaphora resolution, context dependence, and even counterfactual reasoning — a remarkable engineering achievement for its time.

The defining feature of SHRDLU was precisely procedural semantics: when the system parsed a natural language sentence, it did not map it to a set of static logical facts. Instead, it transformed it into an executable procedure. In other words, "understanding a sentence" was equivalent to "knowing which steps to execute." This stands in stark contrast to today's statistics-based deep learning paradigm.

Procedural vs. Declarative: The Essential Difference Between Two Paradigms

The original poster specifically distinguished between two paradigms, a distinction worth unpacking:

Declarative semantics: Maps language to logical assertions or knowledge graph triples, answering "what the world is like." Classic examples include first-order predicate logic, RDF/OWL ontologies, and similar formalisms.
Procedural semantics: Maps language to sequences of operations, answering "how to do something." It is naturally suited to imperative interaction, robot control, and interactive narrative.

The core appeal of procedural semantics lies in its transparency and controllability — every rule is human-readable and debuggable, with none of the "black box" problems associated with large models. This is precisely why revisiting such systems carries unique significance in an era where explainable AI is increasingly valued.

It is worth noting that these two paradigms are not mutually exclusive. In practice, declarative knowledge bases (such as ontologies) often work in tandem with procedural reasoning engines: the former describes domain facts, while the latter defines how to perform operations on those facts. Understanding this collaborative relationship helps engineers make more informed architectural trade-offs.

Current Technical Pathways Worth Exploring

While complete systems on the scale of SHRDLU are rare today, the underlying ideas are scattered across several active open-source ecosystems.

Semantic Parsing and Executable Representations

The modern field of semantic parsing carries forward part of the procedural semantics tradition. Converting natural language into executable formal queries — such as SQL, lambda calculus expressions, or domain-specific languages (DSLs) — is essentially a form of procedural mapping.

Notable tools include Stanford's SEMPRE framework, which supports mapping natural language to λ-calculus expressions or database queries with flexible feature templates. In the text-to-SQL space, there are standard benchmarks like Spider and WikiSQL, along with open-source models such as PICARD and RESDSQL that balance accuracy with execution reliability. These tools blend procedural semantics ideas with neural networks, representing one of the most active areas of current practice and offering a rich set of engineering references for developers interested in this direction.

Grammar Frameworks and Rule Engines

For developers who want to write rules by hand, the following categories of tools are particularly worth attention:

Combinatory Categorial Grammar (CCG) tools such as OpenCCG, which allow syntactic structure to be directly bound to semantic composition operations. CCG's key strength lies in the isomorphism between syntax and semantics: each lexical entry carries both a syntactic type and a corresponding semantic function, so syntactic derivation and semantic composition proceed in perfect lockstep — naturally achieving the "parsing as understanding" effect central to procedural semantics.
Unification Grammar frameworks such as GF (Grammatical Framework), which provide programmable mappings from grammar to semantics. GF was developed by Aarne Ranta and is grounded in Martin-Löf type theory. Its most distinctive feature is the strict separation between abstract syntax (a language-neutral semantic layer) and concrete syntax (the surface forms of individual natural languages). Developers write a single set of semantic rules and then provide separate concrete implementations for English, Chinese, German, and so on, natively supporting cross-lingual semantic equivalence transformations. GF is one of the few rule-driven NLP projects that remains continuously active in both academic research and engineering practice.
Rule engines and expert systems such as Drools and CLIPS are more declarative in orientation, but can achieve procedural execution through the action portions of their rules.

Interactive Narrative Engines: Procedural Semantics in Game Form

The original poster specifically mentioned "story-telling," and the interactive fiction community has mature solutions for exactly this. Systems like Inform 7 use rules written in near-natural-language prose to define world models and responses to player commands — a modern incarnation of procedural semantics in the games domain, and one of the most accessible entry points for newcomers.

Inform 7's rule system is especially noteworthy: it allows authors to write game rules in something close to English prose (e.g., Before taking a locked container, say "It's locked."), and the underlying compiler transforms these rules into executable Z-machine or Glulx bytecode. This design enables non-programmers to participate in building procedural semantics systems, while retaining the determinism and auditability of a rule-based approach. It stands as a successful example of making procedural semantics ideas accessible to a broad audience.

Why This Topic Still Matters in the Age of Large Language Models

The Return of Explainability

In an era where LLMs dominate nearly everything, revisiting rule-driven systems might seem like swimming against the tide. But that is precisely what makes the question so valuable. Rule-based procedural semantics systems offer core advantages that large models cannot match: fully deterministic behavior, fully auditable logic, and zero hallucination risk. In high-reliability scenarios such as safety-critical robot control and industrial command parsing, these properties are irreplaceable.

The emergence of regulatory frameworks like the EU AI Act has further strengthened the engineering imperative for explainability. In high-risk AI application scenarios, systems must be able to provide a clear audit trail for every decision — a natural strength of rule-driven systems, and an external driver pushing the industry to reassess the procedural semantics approach.

Neuro-Symbolic Fusion: A New Life for the Ideas Behind SHRDLU

The more forward-looking direction is neuro-symbolic fusion architecture. This research area has attracted significant investment from top teams in recent years. MIT's NS-CL (Neuro-Symbolic Concept Learner) demonstrated how neural networks and symbolic reasoning engines can collaborate on visual question answering tasks. DeepMind's AlphaGeometry achieved breakthrough results on olympiad-level geometry problems by combining a neural language model with a formal geometric reasoning system. IBM's Logic Tensor Networks further explored how to embed logical constraints directly into a neural network's loss function, enabling end-to-end joint neuro-symbolic training.

One practical engineering approach is to use a large model to handle the ambiguity and diversity of natural language, convert its output into a structured intermediate representation, and then pass that representation to a hand-crafted rule system for deterministic procedural execution. This hybrid architecture retains the linguistic robustness of LLMs while gaining the controllability of a rule system — and it is here that the "language as program" philosophy embodied by SHRDLU finds genuine renewal.

Conclusion

On the surface, the Reddit question was simply looking for a niche open-source project. In reality, it touches on an important and underappreciated technical lineage in the history of NLP. The design philosophy represented by procedural semantics is showing new vitality precisely now, as explainability and system controllability receive growing attention.

For developers interested in exploring this direction, a good starting point is to engage with three entry points: semantic parsing, CCG/GF grammar frameworks, and interactive fiction engines — while keeping a close eye on cutting-edge research in neuro-symbolic integration. SHRDLU may have become history, but the paradigm it pioneered is far from obsolete.