Most developers use programming languages every day.
Few ever see how one works.
Rune was built to change that.
The Compiler Journey
Scroll down or select a compiler stage to watch code convert step-by-step from raw text to outputs.
spell greet(name) { write("Hello ", name) } greet("explorer")
The raw program text loaded into memory characters.
write("Hello ", name)
}
greet("explorer")
A hand-rolled scanner breaks characters into syntactic tokens.
The recursive parser links tokens into structured expressions.
A tree-walk evaluator executes nodes in environment chains.
Declares a function `greet` using the `spell` keyword, then invokes it passing 'explorer' to bind to the `name` parameter in a local environment.
The execution completes and prints values.
The Interpreter Pipeline
Hover over each architectural stage of the compiler stack to inspect its structural role in the execution flow.
01. The Lexer
Converts raw characters into syntax tokens.
02. The Parser
Constructs tree expressions enforcing rules.
03. The AST Node Trees
The syntactic map of the parsed program.
04. The Interpreter
Evaluates syntax nodes recursively.
05. The Environment Stack
Resolves scope values and closures.
The Lexer
Written completely by hand, the lexer scans the source file character-by-character, identifying keywords (like 'spell'), symbols, literals, and identifiers while discarding whitespace and comments.
Inside the Codebase
Rune was constructed entirely by hand. Select a block to open the implementation details and read the source code.
Closure Scope Explorer
Closures hold reference links to parent variables. Click through the step-by-step simulator to visualize the memory allocation changes.
spell make_adder(n) {
spell add(x) {
return x + n
}
return add
}
set add5 = make_adder(5)
write(add5(3))
Engineering Log
A historical log of milestones during the construction of the Rune interpreter.
v0.1.0 Initial Release
A complete tree-walk interpreter in Python: lexer, recursive-descent parser, environment chains, closures, standard built-ins, and an interactive REPL.
v0.2.0 Package Refactor
Split packages into lexer, parser, ast, and runtime modules; isolated control-flow signals and centralizing keywords configuration.
VS Code Extension v1.2.1
Syntax highlighting, snippets, and editor workspace execution integration with robust terminal path auto-discovery.
Website & Docs Launch
Establishing the design system documentation and launching this editorial workspace registry with real-time pipeline visualizers.
Open Source Ecosystem
Explore the repositories that make up the Rune ecosystem. Read, fork, and write.
Core Language Interpreter
The central repository containing the hand-rolled tokenizer, recursive-descent parser, AST nodes, evaluator, and terminal shell (REPL).
Documentation & Guides
The codebase of this web portal, built with Next.js, Tailwind v4, and MDX. Integrates custom design tokens and interactive scopes.
VS Code Language Extension
The VS Code tooling extension providing syntax highlighting configurations, brace completions, and local editor workspace support.
The source is the documentation.
Every module in Rune is built to be read. Dive directly into the implementation of our core subsystems.