SMoL – The Standard Model of Languages

Overview

SMoL (Standard Model of Languages) is an educational framework developed by the Programming Languages group at Brown University. It is designed to teach foundational concepts in programming language semantics through an interactive, executable model. Unlike traditional tutorials that emphasize syntax and APIs, SMoL exposes how code actually executes, making it a powerful conceptual bridge for developers learning low-level execution models, memory semantics, and advanced language features such as closures, mutability, and lexical scope.

The SMoL Tutor, available at https://smol-tutor.xyz, provides a step-by-step walkthrough of small programs. At each step, it reveals what’s happening in memory, the environment (variable bindings), and control flow—giving learners a clear mental model of evaluation and execution.

Motivation

Programming languages may vary in syntax and libraries, but under the surface they share common semantic structures: environments, expressions, function application, memory mutation, and evaluation rules. SMoL isolates these structures and presents them in a minimal, interpretable language designed to teach:

• Expression semantics: how values are computed

• Lexical scoping: how variable references are resolved

• Closures and functions: how functions carry their environment

• Mutable state: how values and memory interact

• Operational semantics: how evaluation unfolds in small steps

For students and engineers alike, SMoL strengthens understanding of how interpreters and compilers actually execute code.

Language Structure and Execution Model

SMoL consists of:

• Expressions: integers, booleans, variable references, binary operations, conditionals, function definitions, applications, sequences, and mutations.

• Environments: map variables to values or memory locations

• Store (Heap): maps memory addresses (boxes) to mutable contents

• Closures: represent functions together with their environment

• Evaluation Steps: computation proceeds through small deterministic transitions

Each expression in SMoL reduces according to clearly defined rules. For example:

…evaluates to a closure that captures the variable x with value 5, enabling correct application later.

The interactive tutor shows all internal state—variables in scope, heap allocations, intermediate expressions—at each step of execution.

Why SMoL Matters (Especially for Rust Learners)

Rust’s power—and its complexity—comes from its explicit model of memory, ownership, and borrowing. These ideas make far more sense once you’ve worked through:

• How environments track bindings

• How values and memory locations interact

• How immutability/mutability is enforced

• How function application carries context

SMoL helps bridge the gap between high-level thinking and low-level control. Rust programmers benefit from SMoL by internalizing concepts like:

Use in Programming Language Design and Beyond

If you’ll be implementing your own programming language, closely related to SMoL, having walked through SMoL, you’ll already:

• Understand how evaluation contexts work

• Know what your interpreter should track and enforce

• Be able to model control flow, memory, and scope precisely

This is not just about learning a language —it’s about thinking like a language runtime.

Conclusion

SMoL is not a general-purpose language—it’s a teaching tool. But its clarity in modeling the semantics of programming languages makes it an ideal preparation for implementing interpreters, understanding ownership and memory, and diving into modern systems languages like Rust.

By mastering SMoL, you develop the mental models needed to reason about how languages work, not just how to write code. That understanding becomes your foundation for both language implementation and advanced language use.