awesome-repositories.com
Blog
MCP
awesome-repositories.com

Discover the best open-source repositories with AI-powered search.

ExploreCurated searchesOpen-source alternativesSelf-hosted softwareBlogSitemap
ProjectMCP serverAboutHow we rankPress
LegalPrivacyTerms
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
munificent avatar

munificent/craftinginterpreters

0
View on GitHub↗

Craftinginterpreters

Crafting Interpreters is a comprehensive resource for building a complete programming language from scratch. It provides a structured guide to the fundamental components of language implementation, including lexing, parsing, and the design of execution engines.

The project demonstrates two distinct approaches to language execution: a tree-walking interpreter that evaluates source code by traversing its abstract syntax structure, and a stack-based virtual machine that compiles code into custom bytecode for execution. These implementations are supported by core runtime mechanisms such as lexical scoping environments and automated memory management systems.

The guide covers the design of tracing garbage collectors and tagged union value representations to manage data and resources efficiently. It serves as a technical reference for developing language front-ends and custom virtual machines, detailing the processes required to transform source code into executable logic.

AI search

Explore more awesome repositories

Describe what you need in plain English — the AI ranks thousands of curated open-source projects by relevance.

Start searching with AI
www.craftinginterpreters.com
↗

Features

  • Language Implementation Guides - Offers a comprehensive resource for building a complete programming language from scratch.
  • Programming Language Architectures - Provides a comprehensive guide to building custom programming languages from scratch.
  • Stack-Based Virtual Machines - Implements a high-performance execution engine that processes custom bytecode on a virtual stack.
  • Tree-Walking Interpreters - Evaluates source code by traversing the abstract syntax tree directly to execute logic.
  • Pedagogical Interpreters - Serves as a pedagogical implementation that evaluates source code by traversing its structural representation.
  • Compiler and Database Projects - A hands-on guide to implementing a programming language interpreter.
  • Compiler Theory Books - Comprehensive guide to building a full-featured interpreted scripting language.
  • Interpreted Runtimes - Executes source code directly by traversing its structure without a prior compilation step.
  • Virtual Machines - Compiles source code into specialized instructions and runs them on a virtual machine.
  • Garbage Collectors - Provides a memory management mechanism that tracks object references during runtime to reclaim unused data.
  • Memory Management Systems - Tracks object references during program execution to identify and remove unused data.
  • Garbage Collection - Identifies and reclaims unreachable memory by periodically scanning object references.
  • Single-Pass Compilers - Transforms source code into executable instructions in one traversal to minimize build overhead.
  • Lexical Scoping Mechanisms - Implements nested symbol tables to manage variable visibility and lifetime within the language runtime.
  • Abstract Syntax Tree Tools - Provides utilities for programmatically parsing and traversing source code structures.
10,539 stars·1,244 forks·HTML·other·18 views

Star history

Star history chart for munificent/craftinginterpretersStar history chart for munificent/craftinginterpreters

How this analysis was created: This summary and feature list are AI-generated from collected project material and can contain mistakes. Stars, license and language are imported from GitHub. Inclusion does not mean that we have tested or audited this project. Check the source documentation for any feature you depend on. Learn more on our About page.

Frequently asked questions

What does munificent/craftinginterpreters do?

Crafting Interpreters is a comprehensive resource for building a complete programming language from scratch. It provides a structured guide to the fundamental components of language implementation, including lexing, parsing, and the design of execution engines.

What are the main features of munificent/craftinginterpreters?

The main features of munificent/craftinginterpreters are: Language Implementation Guides, Programming Language Architectures, Stack-Based Virtual Machines, Tree-Walking Interpreters, Pedagogical Interpreters, Compiler and Database Projects, Compiler Theory Books, Interpreted Runtimes.

Which projects share features with munificent/craftinginterpreters?

Projects with overlapping indexed features include: chakra-core/chakracore — ChakraCore is an embeddable JavaScript engine and high-performance scripting runtime. It provides a just-in-time… thejameskyle/the-super-tiny-compiler — This project is an educational compiler implementation and a minimalist compiler construction tutorial. It serves as a… lua/lua — Lua is an embeddable scripting language written in ISO C, designed to be integrated into host applications for runtime… kanaka/mal — This project is a Lisp interpreter implementation guide and framework designed to teach the core principles of… orangeduck/cello — Cello is a programming language extension for C that provides a higher-level implementation of the language. It… openjdk/jdk — The Java Development Kit is a comprehensive software development environment designed for compiling, debugging, and…

Projects sharing features with Craftinginterpreters

These projects share indexed features with Craftinginterpreters. Shared tags can include platform or build tooling; verify the primary use case before treating a result as a replacement.
  • chakra-core/chakracorechakra-core avatar

    chakra-core/ChakraCore

    9,242View on GitHub↗

    ChakraCore is an embeddable JavaScript engine and high-performance scripting runtime. It provides a just-in-time compiler that converts JavaScript source code into optimized machine code during runtime to increase execution speed and throughput. The engine utilizes a multi-tiered compilation pipeline and tiered machine code generation to balance startup time with execution speed. Memory is managed via a concurrent garbage collector that reclaims unreachable objects on background threads to minimize application pauses. The project provides capabilities for embedded JavaScript execution and au

    JavaScriptchakrachakracorecplusplus
    View on GitHub↗9,242
  • thejameskyle/the-super-tiny-compilerthejameskyle avatar

    thejameskyle/the-super-tiny-compiler

    28,527View on GitHub↗

    This project is an educational compiler implementation and a minimalist compiler construction tutorial. It serves as a practical example of how to build a functional compiler through a simplified end-to-end development process, transforming source code into executable instructions. The implementation is designed to teach the fundamentals of language implementation and compiler design. It focuses on the essential mechanics of transforming source code by demonstrating the core architecture of a translation process. The system covers the primary stages of compilation, including lexical analysis

    JavaScript
    View on GitHub↗28,527
  • lua/lualua avatar

    lua/lua

    9,768View on GitHub↗

    Lua is an embeddable scripting language written in ISO C, designed to be integrated into host applications for runtime customization. It provides a C-based scripting engine and a prototype-based object model that utilizes associative arrays and metatables to implement inheritance and complex data structures. The language features a cooperative multitasking system that manages concurrent execution threads via coroutines and an incremental garbage collector for automatic memory management. It includes a safe code sandbox to isolate global state and run untrusted scripts within a protected envir

    C
    View on GitHub↗9,768
  • kanaka/malkanaka avatar

    kanaka/mal

    10,665View on GitHub↗

    This project is a Lisp interpreter implementation guide and framework designed to teach the core principles of programming language design. It provides a structured, step-by-step technical framework for building a functional Lisp language from scratch, featuring a specialized interpreter engine and an S-expression parser that converts syntax into abstract syntax trees. The project emphasizes a code-as-data metaprogramming framework, enabling the implementation of macros, quoting, and quasiquoting to transform expressions during evaluation. It is designed with host language agnosticism, allowi

    Assemblybashcc-plus-plus
    View on GitHub↗10,665
Compare all 30 related projects→