Projects sharing features with ChezScheme

The Rust Programming Language Book is the official technical guide and educational resource for the Rust language. It provides a comprehensive walkthrough of the language's design, focusing on its core identity as a systems programming language that enforces memory safety and high-performance execution without the need for a garbage collector. The project is distinguished by its focus on ownership, borrowing, and lifetime tracking, which allow the compiler to verify memory safety and thread safety at compile time. It covers the language's unique approach to zero-cost abstractions, including t

This project is a comprehensive Lisp AI implementation library that provides reference implementations for various artificial intelligence paradigms and symbolic algorithms. It functions as a multi-purpose toolkit containing a logic programming engine, a natural language processing suite, and a symbolic mathematics toolkit. The library is distinguished by its diverse architectural frameworks, including a Prolog-style execution engine that uses unification and goal-driven backtracking, and a system for simulating human decision-making through expert system shells and certainty factors. It also

Swift Evolution serves as the central governance and design platform for the Swift programming language. It provides a structured, collaborative framework for tracking, discussing, and managing the formal proposals and technical goals that define the language's syntax, semantics, and core features. By maintaining a comprehensive collection of design documentation, the project ensures the long-term stability and consistency of the language as it matures. The repository acts as the primary hub for the language's evolution, coordinating community feedback and technical decisions through a transp

OCaml is a strongly typed functional language featuring a sophisticated type system and a focus on safety and expressiveness. It provides a comprehensive compiling toolchain that transforms source code into either portable bytecode or high-performance native binaries. The project is distinguished by a shared memory parallel runtime that executes computations across multiple processor cores using domains, and an algebraic effect system for managing side effects and control flow through execution context handlers. It also includes a dedicated parser generator to automatically create lexers and

Crystal is a statically typed, compiled programming language designed for high performance and memory safety. It leverages an LLVM-based compiler to translate source code into optimized machine-executable binaries, while its type-inference-based static analysis enforces strict safety rules during the build process. The language distinguishes itself through a fiber-based concurrent runtime that manages lightweight execution units for asynchronous input and output without blocking the main process. It also features a powerful compile-time macro system that allows for the inspection and transfor

Haste-compiler is a source-to-source compiler and web framework that translates Haskell source code into JavaScript programs for execution in web browsers and server environments. It enables the creation of unified web applications from a single type-safe codebase, automatically generating communicating client and server binaries while preserving static type guarantees across tiers. The system translates high-level code through an existing compiler infrastructure paired with custom code generators, supported by an AST-based optimization and minification pipeline for producing lean deployment

The .NET Compiler Platform is a collection of open-source APIs for C# and Visual Basic that provides deep code analysis, refactoring, and automated source code generation. It serves as the core infrastructure for building development tools, offering a platform to inspect, modify, and understand source code through immutable syntax trees and semantic models. The platform distinguishes itself by providing full-fidelity syntax trees that preserve every character of source code, including whitespace and comments, alongside an incremental compilation pipeline that enables near-instant feedback dur

Zig is a low-level systems programming language designed for writing high-performance software that interacts directly with hardware. It focuses on the transformation of source code into machine binaries for the execution of low-level operations. The project is distinguished by its native support for cross-compilation, allowing binaries for various operating systems and CPU architectures to be built from a single host. It provides direct interoperability with the C language, enabling the import of headers and function calls without a foreign function interface. The language utilizes manual m

Codon is an LLVM-based Python compiler and statically typed implementation that translates source code into optimized machine instructions. It functions as a high-performance numerical backend and a GPU computing framework designed to remove runtime overhead. The project implements a compiled alternative to NumPy, translating array logic directly into machine code. It differentiates itself by generating specialized hardware kernels for graphics processors and utilizing static type inference to enable aggressive machine-code optimization. The system provides capabilities for parallel workload

Stack is a build tool, package manager, and project bootstrapper for the Haskell language. It provides a consistent environment for compiling source code, managing project binaries, and executing programs. The system ensures reproducible builds through snapshot-based dependency resolution and manages the installation of specific compiler binaries to match project requirements. It utilizes content-addressable package storage and local-path caching to maintain the integrity of source code and avoid redundant downloads across different projects. The toolset covers the full development lifecycle

Mono is an open source implementation of the .NET Framework that provides a managed execution environment, base class libraries, and a cross-platform virtual machine. It serves as a compliant implementation of the ECMA Common Language Infrastructure standard, enabling the execution of intermediate language binaries across different operating systems. The project includes a complete toolset for C# development, featuring a command line compiler and CLI to transform source code into executable assemblies. It distinguishes itself with a flexible managed memory system that supports multiple automa

Reason is a strongly typed functional language and multi-target compiler designed to produce either JavaScript for web environments or native machine code for operating systems. It serves as an OCaml-compatible language that shares an abstract syntax tree with OCaml, providing a practical syntax for the OCaml ecosystem. The project functions as a type-safe frontend language, incorporating JSX support to build user interfaces through structural elements that translate into type-safe function calls. It enables deep integration with the JavaScript ecosystem, allowing the use of existing librarie

JNA is a foreign function interface and native memory mapper that allows Java applications to call functions in shared native libraries without writing custom JNI wrapper code. It serves as a JNI alternative framework for invoking C functions and mapping native data structures using high-level interfaces. The library distinguishes itself through its ability to translate Java objects and primitives into C-style structs, unions, and pointers for cross-platform memory exchange. On Windows, it provides a dedicated toolkit for interacting with Component Object Model objects using both early and la

Gop is a general purpose programming language and cross-language compiler designed to unify assets and libraries from multiple programming ecosystems into a single shared environment. It translates high-level source code into executable binaries using specialized backends tailored for different target environments. The project features a system for natural language programming, transforming human-readable instructions written in plain English into executable code. It also functions as a cross-language tool that imports and integrates external libraries and assets from different language ecosy

JavaCPP is a JNI C++ bridge and foreign function interface that provides a binding generator, a native library loader, and a native memory manager. It automates the creation of Java wrappers around native C++ headers and shared libraries to enable interoperability between the two languages. The project features a C++ binding generator that parses header files to automatically produce the necessary glue code and interfaces for calling native functions. It includes a native library loader that locates and extracts platform-specific binaries from the classpath into a local cache for runtime exec

Pry is a programmable Ruby shell, REPL console, and runtime developer environment. It serves as a debugging toolkit for inspecting object state, navigating bindings, and evaluating code within a running Ruby program. The project differentiates itself through advanced introspection and live iteration capabilities. It allows users to inject an interactive console into a running program at specific points to inspect local state and navigate different object scopes. It further enables live code iteration by integrating with external system editors to modify and reload method definitions without r

This project is a collection of programming language references and syntax cheat sheets designed for rapid developer onboarding. It serves as a library of code-based documentation that uses valid source code files to provide whirlwind tours of various language specifications. The project focuses on programming language learning by providing concise, commented code examples that explain core features and syntax in place. This approach enables developers to quickly grasp language-specific patterns, data types, and execution flow through a consistent reference format. The content covers a broad

CoreCLR is a runtime environment that manages the execution, memory, and basic types for applications built on the .NET platform. It serves as a managed execution environment that handles low-level system interactions and provides primitive data types for high-level application code. The project functions as a JIT compilation engine and a garbage collected runtime. It translates intermediate language into machine code at runtime for execution on specific hardware and automatically reclaims unused memory to prevent leaks. The system covers broad capability areas including managed code executi

Janet is a Lisp-based dynamic programming language featuring a register-based bytecode virtual machine and an embeddable scripting engine. It functions as a fiber-based concurrency runtime and includes a parsing engine based on Parsing Expression Grammars. The project is distinguished by its ability to be integrated into C or C++ applications via a minimal header interface. It utilizes a Lisp-style macro system for compile-time code transformation and employs prototype-based table inheritance for object-oriented behavior. The runtime covers a broad set of capabilities, including asynchronous

gdext provides a set of language bindings for writing high-performance native game logic in Rust for the Godot 4 engine. It serves as a framework for creating native engine extensions and custom classes via the GDExtension library, allowing developers to extend core engine functionality without recompiling the engine source code. The project includes a dedicated Rust WebAssembly toolchain to compile native logic into modules for execution in web browsers. This system supports WebAssembly-compatible compilation with specific configurations for web threading and module debugging. The toolkit c

MicroPython is a lean implementation of Python 3 optimized to run on microcontrollers and other resource-constrained systems. It serves as a cross-platform embedded runtime and hardware abstraction layer, providing a firmware framework that maps high-level software commands to specific microcontroller registers across diverse processor architectures. The project functions as an embedded language interpreter that enables rapid prototyping on hardware through an interactive read-eval-print loop. It supports a wide range of target environments, including ARM, ESP32, STM32, RISC-V, and WebAssembl

Frege is a purely functional programming language that compiles to JVM bytecode, providing Haskell-like semantics for the Java platform. It is built around a Haskell-inspired compiler that implements non-strict evaluation and a static type inference system to ensure data immutability and prevent side effects. The project distinguishes itself through a sophisticated type system featuring rank polymorphism, type-class based dispatch, and static purity enforcement. It includes a JVM language bridge and a foreign function interface that map Java classes and interfaces into functional types, allow

Bun is a high-performance runtime environment designed to execute JavaScript and TypeScript applications with minimal latency and high throughput. Built on a native core implemented in Zig, it provides a unified execution engine that leverages JavaScriptCore for efficient memory management and low-latency startup. The project functions as an all-in-one toolchain, integrating a native bundler, transpiler, package manager, and test runner into a single command-line interface. What distinguishes Bun is its focus on native system integration and developer productivity. It features a high-performa

Gleam is a statically typed, functional programming language designed for building scalable and maintainable applications. It operates as a cross-platform development ecosystem that compiles source code to run on the Erlang virtual machine or within JavaScript environments. The language integrates a package manager and build system that automates dependency resolution, project compilation, and the generation of software bills of materials. The language distinguishes itself through a focus on type-driven domain modeling and a robust foreign function interface framework. By encoding business ru

bflat is a native compiler and ahead-of-time binary generator for C#. It transforms source code into self-contained native executables and machine code that run without requiring a separate runtime environment. The project features a cross-platform native toolchain capable of generating binaries for multiple operating systems and architectures from a single environment. It includes a mechanism for exporting C# logic as shared native libraries via a foreign function interface for integration with other programming languages. To support resource-constrained environments, it provides a binary o

V is a statically typed, compiled programming language designed for high-performance systems development. It prioritizes memory safety and execution speed by enforcing strict type checking and immutable defaults, while generating native machine code for multiple hardware architectures. The language is built around an integrated toolchain that includes a compiler, package manager, formatter, and testing utilities within a single executable, facilitating rapid development cycles. What distinguishes V is its focus on developer productivity and interoperability. It provides a direct interface for

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