Babashka is a native Clojure interpreter for scripting, compiled with GraalVM native-image to produce a self-contained, fast-starting binary (`bb`). In production, it serves as a replacement for bash or Python scripting in Clojure, offering a REPL, task runner, nREPL server, HTTP client/server, process spawning, file I/O, database access via JDBC, and foreign function interface (FFI) to C libraries. The architecture is a monolith with modular feature flags: environment variables such as `BABASHKA_FEATURE_CSV` or `BABASHKA_FEATURE_JDBC` control which optional libraries (XML, YAML, CSV, Transit, http-kit, spec, logging, etc.) are compiled into the binary. The core interpreter is SCI (Small Clojure Interpreter), extended with a rich set of built-in namespaces that wrap popular Clojure libraries. Build scripts and CI pipelines automate testing on Linux, macOS, and Windows, and the project maintains an extensive library compatibility test suite with over 100 third-party Clojure libraries pinned to specific git SHAs. The codebase demonstrates exceptional craftsmanship: the JLine-based REPL with inline autosuggestion and eldoc, the FFI trampoline dispatch, the custom GraalVM features for binary size optimization, and the deftype map interface support are all non-obvious solutions to real problems in building a scripting runtime on the JVM. While primarily an application, the repository also contains a valuable data asset in `test-resources/lib_tests/bb-tested-libs.edn`, a curated registry of library compatibility that could support research on Clojure library portability.
PsySH is a production-grade interactive PHP shell, REPL, and runtime debugger. It accepts PHP input from a terminal, validates and rewrites it through a pipeline of PHP-Parser AST passes, evaluates it inside an isolated execution context, and renders results using a custom VarDumper presenter, formatters, and support for paging, themes, clipboard copy, and OSC 8 hyperlinks. It is distributed both as a Composer library and a self-updating PHAR binary, with primary entry points in src/functions.php (sh(), debug(), info(), bin()) and the bin/psysh launcher. The architecture is modular and interface-driven: a central Shell/Configuration core coordinates commands built on Symfony Console, multiple readline backends (GNU, libedit, userland, and a new experimental interactive readline), a completion engine with typed sources and refiners, legacy tab-completion matchers, execution-loop listeners, manual/documentation loaders, and updater strategies for both the PHP manual and PsySH itself. The main data flow is: terminal input -> readline -> code cleaning/validation -> eval -> output; completion and history are layered on top via AST analysis, fuzzy matching, suggestions, and JSONL-backed history persistence. The codebase is unusually thorough for a developer tool: nearly every subsystem has unit and integration tests, CI spans PHP 7.4 through 8.6 plus 32-bit and downstream consumer tests, and static analysis baselines manage compatibility across php-parser 4-5 and Symfony 3.4-7.x. The main weaknesses are the vendored Hoa terminal library, a wide compatibility surface requiring deprecation baselines and version shims, and the complexity of the experimental interactive readline, which creates maintenance risk. Overall this is a high-craft, actively maintained project with several genuinely reusable components.
rustyline is a mature Rust library providing GNU Readline-style interactive line editing for terminal applications. It is not a standalone application but a reusable dependency used by CLIs, REPLs, and shells. The core is an Editor generic over helper and history types, with pluggable traits for completion, hints, highlighting, validation, and custom key bindings. It supports Emacs and Vi keymaps, Unicode/grapheme-aware editing, multi-line input, kill ring, undo/redo, and multiple history backends including in-memory, file, and SQLite. The architecture is trait-driven and platform-aware, with separate Unix and Windows TTY implementations behind a common abstraction, plus a derive macro crate to reduce boilerplate for custom helpers.
hcc is a compiler for the HolyC language, a derivative of TempleOS HolyC. It supports both ahead-of-time (AOT) compilation to x86_64 and AArch64 assembly and just-in-time (JIT) compilation for in-memory execution. The system includes a full front-end (lexer, parser, AST, SSA-based IR), optimization passes, register allocation, and backends for x86_64 and AArch64. Additionally, it provides a REPL, a Language Server Protocol (LSP) server, an inline assembler (TempleOS-style), a disassembler, and a control-flow graph visualizer. The standard library is written in HolyC and offers data structures (lists, vectors, hash maps, red-black trees), JSON/CSV parsers, SQLite bindings, networking, threading, coroutines, and system call wrappers. The project is a self-contained, well-structured compiler toolchain with extensive tests and active development.
PrettyPrompt is a cross-platform .NET library that replaces `Console.ReadLine()` with a feature-rich terminal input experience. It provides syntax highlighting, autocompletion (with documentation and overload panes), persistent history, multi-line editing with word wrapping, text selection and clipboard operations, and undo/redo. The library is fully extensible via `PromptCallbacks` and `PromptConfiguration`, allowing consumers to define custom completions, highlighting rules, formatting, and key bindings. It targets .NET 10 and uses ANSI escape codes for rendering, making it compatible with any modern terminal. Architecturally, the system is composed of several decoupled layers: a document model (`Document`, `StringBuilderWithCaret`) with grapheme-aware operations; an input system based on `KeyPress` and `KeyPressPattern` for flexible key binding; a rendering pipeline that computes minimal ANSI diffs via `IncrementalRendering` and `Screen`/`Cell` abstractions; and UI panes (`CodePane`, `CompletionPane`, `OverloadPane`) that handle specific interactions. The library employs object pooling (`Pools`) and caching (`StringCache`) to minimize allocations in the per-keystroke hot path. The library is extensively tested with unit tests, integration tests (using recorded keystroke logs), and benchmarks that measure per-keystroke and steady-state rendering costs. It is actively maintained, with regular releases on NuGet and continuous integration across Windows and Ubuntu. Notable external dependencies are `Wcwidth.Sources` (for Unicode display width) and `TextCopy` (for clipboard access); both are wrapped with resilience and fallback behavior.
ClojureScript is a compiler and toolchain that translates Clojure (a Lisp dialect) into JavaScript, targeting the Google Closure Compiler for advanced optimization. In production, it takes ClojureScript source files, analyzes them (macro expansion, type inference, namespace resolution), emits JavaScript, and optionally invokes the Closure Compiler for bundling, minification, and dead-code elimination. The system also provides a REPL (browser and Node.js), a self-hosted compiler (ClojureScript compiling ClojureScript), a full standard library (cljs.core, clojure.string, clojure.set, etc.), a testing framework (cljs.test), a specification system (cljs.spec.alpha), source-map support, and dependency management for npm/foreign JavaScript libraries. The architecture is a library/toolchain rather than a deployed service: it runs on the JVM via Clojure and can also self-host on JavaScript runtimes. Key entry points include the CLI (cljs.main), the build API (cljs.closure/build), the compiler API (cljs.compiler.api), and the analyzer API (cljs.analyzer.api). External dependencies include Clojure, Google Closure Compiler, Google Closure Library, tools.reader, Transit, and test.check. The codebase is large and mature, with extensive regression tests and a detailed changelog, though some samples and design documents are outdated.
Murex is a cross-platform shell and scripting language designed as a more readable, safe, and type-aware alternative to Bash. In production it works as both an interactive REPL (with autocomplete, hint text, preview panes, spellchecking, and job control) and a scripting interpreter with a custom expression language, typed pipelines, exception handling (try/catch/trypipe), multi-scope variables, a built-in unit test framework, event hooks (onPrompt, onKeyPress, onFileSystemChange, onSignalReceived), an HTTP client, and a package/module manager. The defining architectural feature is that data in pipelines carries type metadata: JSON, YAML, CSV, TOML, XML, S-expressions, HCL and more are first-class structured objects with registered Marshal/Unmarshal/ReadArray/ReadMap/ReadIndex hooks, so builtins like alter, tabulate, count, and jsplit operate on structured data rather than raw text. The implementation is Go (with a JS/WASM interpreter variant), organized around lang/ (parser, expression engine, process lifecycle), shell/ (interactive terminal layer), builtins/ (roughly 200 commands, data type adapters, pipes, and event handlers), config/ (profile-driven runtime configuration), and utils/ (standalone helper libraries).
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).
Infiltrator.jl is a Julia package that provides an interactive debugging macro, @infiltrate, which acts as a breakpoint with negligible runtime overhead. When triggered, it opens a custom REPL (infil>) allowing developers to inspect local variables, stack frames, module bindings, and evaluate arbitrary expressions. It supports conditional breakpoints, toggling infiltration points on/off, exfiltration of variable values to a store, and integration with Revise.jl for live code updates. The package is designed for development-time debugging and enforces that @infiltrate fails at compile time in package code to prevent accidental commits. It relies heavily on Julia internals (REPL, Core.Compiler, Base.@locals) and maintains compatibility across Julia versions 1.6 through 1.13 via version-adaptive code paths and extensive golden-file test outputs. This is a pure developer tool with no data analysis or research orientation.
Xonsh is a cross-platform, Python-powered interactive shell that combines Python syntax with shell subprocess commands. The codebase implements a full shell environment with a custom parser (PLY-based with version-specific extensions), an execution engine that compiles xonsh code to Python AST, a rich tab-completion system with multiple backends (bash, git, pip, python, custom completers), a pluggable history backend (JSON, SQLite), a prompt system with git status and virtualenv information, and a subprocess management layer with job control. It also includes CLI tools for formatting, linting, and interactive configuration (xonfig wizard and web UI). The architecture is monolithic with a clear module structure: parsers, executers, completers, prompts, history, procs, and shells. External dependencies include prompt_toolkit, pygments, and PLY (vendored). The repository is actively maintained with frequent releases, supports Python 3.10+, and has an extensive test suite. Some technical drift exists due to deprecated API shims, multiple parser versions, and LLM-generated tests, but the core is well-engineered.
Yaegi is a Go interpreter written in Go, designed for embedding scripting capabilities into Go applications, running Go scripts, or providing an interactive REPL. The architecture consists of a core interpreter package (`interp`) that parses Go source code into an AST, performs type checking and control flow graph (CFG) generation, and executes the CFG via a runtime engine. Standard library support is provided through auto-generated reflective wrappers (`stdlib/`) that expose Go's standard library symbols to the interpreter. A command-line tool (`cmd/yaegi`) offers subcommands for running scripts, testing, and extracting stdlib wrappers. The project also includes code generators (`internal/cmd/genop`, `extract/extract.go`) that automate the creation of operator implementations and stdlib bindings. External dependencies are limited to the Go standard library; the interpreter itself has no third-party runtime dependencies. Key entry points are `interp.New()`, `interp.Eval()`, and `interp.Use()` for embedding, and the `yaegi` CLI for standalone use.
DeepTide is a cross-platform terminal AI coding agent. The Rust workspace (deeptide-core, deeptide-host, deeptide-cli, deeptide-gui) implements the production agent engine: an interactive REPL session with an agent loop, tool dispatch (bash, edit, web, git, memory, MCP, LSP, vision, cron, planning), cross-provider model routing with local-first/cloud-escalation policies, cost tracking, tokens-per-second telemetry, tool usage observability, durable memory with BM25 retrieval ranking, session import/checkpoint/rewind, sensitive-file read protection, and a theme system for syntax highlighting and diffs. The CLI and GUI share a common host layer, and the npm package downloads prebuilt Rust binaries. Architecturally it is a multi-crate Rust workspace plus supporting native components: native/ds4 is a hard-forked DeepSeek V4 Flash Metal inference engine for local LLM execution, and native/dsgo is a Swift gateway that translates between Anthropic and OpenAI protocols with SSE streaming. Primary entry points are crates/deeptide-cli/src/main.rs (CLI), crates/deeptide-gui/src/main.rs (eframe/egui GUI), and bin.js (Bun launcher that delegates to @paean-ai/zero-cli). External dependencies include DeepSeek/Anthropic/OpenAI-compatible APIs, local Metal GPU inference, and GitHub Releases for binary distribution. The repo also contains 50+ self-contained HTML5 Canvas pixel-art games and Three.js showcases under samples/, which appear to be AI-generated demo content demonstrating agent output quality rather than core product code. These share heavily duplicated boilerplate (seeded RNG, localStorage save/load, bilingual i18n, screen state machines). The core Rust code is well-tested with integration tests covering routing, cost tracking, memory ranking, tool result summarization, and slash commands; live API tests are marked #[ignore]. Hybrid note: while primarily an application, it contains research-oriented elements such as memory capture benchmarks (benchmarks/auto_capture_bench.py), prompt cache layout benchmarks (benchmarks/cache_memory_bench.py), and deterministic puzzle generation algorithms with uniqueness verification.
react-py is a React library that enables running Python code directly in the browser by leveraging Pyodide, a Python distribution compiled to WebAssembly. The library provides a PythonProvider context and two hooks (usePython and usePythonConsole) for executing Python scripts and interacting with an interactive console. Python execution occurs in a dedicated web worker via comlink-based RPC, preventing UI blocking. A service worker intercepts synchronous fetch requests from the worker to implement stdin input (e.g., input() function). The library supports loading Pyodide official packages and micropip-installable packages, file system operations (read/write/mkdir/rmdir), module watching for hot-reloading, execution timeouts, lazy worker initialization, and automatic package import detection. The architecture is cleanly separated into provider, hooks, worker scripts, and types, with the documentation site (Docusaurus) serving as both documentation and interactive playground.
This repository provides a toolkit for developing JavaScript for Automation (JXA) scripts on macOS using TypeScript. It includes packages for running JXA code from Node.js (@jxa/run), an interactive REPL (@jxa/repl), type definitions for macOS applications (@jxa/types and @jxa/global-type), and a tool to generate TypeScript definitions from Apple's SDEF files (@jxa/sdef-to-dts). The monorepo structure (managed by Lerna) separates concerns into focused packages, enabling type-safe and efficient automation of macOS applications.
jsconsole is a web-based JavaScript REPL and remote debugging tool. The frontend is a React (Preact-compat) single-page application with Redux state management, allowing users to type and execute JavaScript commands in a sandboxed iframe. Results are rendered with a rich type-aware display that supports expand/collapse for objects, arrays, functions, promises, and more. The backend is a Node.js/Express server that serves the static build and provides real-time communication via Server-Sent Events (SSE) for remote debugging sessions. Users can start a remote session (listen) to bridge console.log calls from another browser or device back to the main console, and also inject commands remotely. Architecturally, the codebase follows a standard client-server model with a React SPA. It makes clever use of AST parsing (via Babylon) in the `preProcess` function to handle JavaScript declarations (const/let) and async/await in the REPL, transforming input so that eval returns the final expression value. The backend uses a lightweight custom SSE session manager (`lib/es.js`) that could be extracted for other real-time projects. However, the project is technically very dated, with React 15, Webpack 2, and many other dependencies from 2017-2018. Despite this, the core REPL logic and type-rendering components are well-architected and could serve as a reference implementation for similar tools.