LIPS is a Scheme (R7RS/R5RS) interpreter written in JavaScript, designed to run in browsers, Node.js, and Web Workers. The core interpreter (lexer, parser, evaluator, environments, types, serialization) lives in a monolithic `src/lips.js` (~10k+ lines), while roughly half the standard library is written in Scheme itself (`lib/`), including R7RS base procedures, SRFI implementations, and a bootstrap library. The system is self-hosting: the standard library is compiled to a binary CBOR+LZJB format (`dist/std.xcb`) for fast loading. The interpreter features both unhygienic macros (`define-macro`) and hygienic macros (`syntax-rules` with `free-identifier=?`), first-class continuations with tail-call optimization, a full numeric tower (complex numbers, exact rationals), and deep JavaScript interop (dot access, `new`, Promises, ES modules, `require`). It ships with a REPL (terminal and browser), a CLI (`bin/lips.js`), and a Docusaurus documentation site with an interactive interpreter. The codebase is actively maintained (last commit Sept 2026) with a comprehensive test suite including R7RS conformance tests, snapshot tests for parser output, and Scheme-level test files. Known limitations include some failing tests (marked `test.failing`), a monolithic core that is hard to navigate, and dual macro systems that can confuse contributors. The project is in beta with frequent breaking changes (documented in CHANGELOG.md).
Calysto Scheme is a sophisticated Scheme interpreter implemented in Python that integrates with Jupyter notebooks. It features a multi-stage compilation pipeline (CPS → DS → RM → Python) with JIT compilation, continuation support (call/cc), and seamless Python interoperability. The system includes advanced optimizations like persistent vectors for O(1) lexical address lookup, epoch-based cache invalidation, and escape analysis for JIT inlining. It's used in educational contexts and provides debugging tools like a stepper-debugger, making it both a practical development tool and a platform for teaching programming language concepts.
Bob is a Scheme language implementation consisting of a Python interpreter, compiler, and virtual machine (VM), plus an optional C++ VM implementation (BareVM). The system compiles Scheme source code to custom bytecode, which can be executed by either the Python VM or the C++ BareVM. It includes features like bytecode serialization/deserialization and WebAssembly compilation. The architecture is modular with clear separation of concerns: parser, compiler, bytecode handling, VM execution, built-in functions, expression representation, and environment management. Key entry points are in bob/cmd.py (command-line interface) and example scripts demonstrating interpretation, compilation, and execution workflows.
This repository is a personal study record for UC Berkeley's CS61A (Structure and Interpretation of Computer Programs) course, completed in 2024. It contains the author's solutions to homework assignments (hw01–10), lab exercises (lab00–12), and four major projects: Hog (dice game), Cats (typing tutor), Ants (tower defense web game), and a Scheme interpreter. The codebase is hybrid in nature: it is primarily an educational portfolio, but it includes several functional application components such as a web-based Scheme editor with interactive visualizations (environment diagrams, substitution trees, turtle graphics), a Flask-based multiplayer typing test, and a real-time web game (Ants) with vendored dependencies (Flask, SocketIO, Werkzeug). The repository also contains a complete Scheme interpreter (parser, evaluator, REPL) and a SQL lab. The code is functional and demonstrates understanding of core CS concepts, but it suffers from massive duplication of editor assets (Ace editor, static files) across multiple assignment directories, vendored third-party libraries that are not centrally managed, and a lack of modularization. It is not intended for production use or external reuse, but the Scheme editor framework and the ucb.py utility module exhibit patterns that could be extracted for educational tooling.
This repository is a comprehensive, cross-implementation benchmark suite for R7RS Scheme. It provides a standardized harness that compiles and runs approximately 50 benchmarks (covering numerical, symbolic, I/O, GC, and meta-circular workloads) across more than 30 Scheme implementations, capturing execution times and correctness results. The suite exposes portability gaps, performance differences, and implementation bugs through its per-implementation prelude/postlude system, which adapts the common benchmark code to each Scheme's dialect. Results are output as CSV files and aggregated into summary tables and HTML charts (via graph-gmean.scm and graph.scm). While the benchmarks are well-structured and the harness is robust, many implementations are broken or incomplete, preludes are fragile workarounds, and the codebase shows age-related drift (e.g., deprecated APIs, hardcoded paths, and inputs too small for modern hardware).
This repository is a chaotic, joke-oriented collection that explicitly accepts all pull requests. The dominant content is a vendored copy of the Ruby on Rails framework (circa Rails 6.0 alpha), comprising thousands of files including core libraries, generators, tests, and documentation. Interspersed are hundreds of trivial or humorous contributions: random scripts in dozens of languages, ASCII art, brainfuck interpreters, fake malware, and absurd READMEs. There is no coherent application, no unified build system, and no original reusable components. The repo serves as a meta-experiment in open-source chaos rather than a functional tool. It is not suitable for production use or as a dependency.