Open-source alternatives to Reason

This project is a comprehensive guide and educational resource for the TypeScript language. It covers the fundamental principles of the language, including its structural type system, static type analysis, and the process of transpiling typed source files into JavaScript. The material details how to model complex data and reusable type logic using generics, conditional types, and mapped types. It also explains the use of declaration files to provide type safety for external JavaScript libraries and the integration of type checking into existing JavaScript projects via JSDoc annotations. The

c3c is the compiler for the C3 programming language, transforming source code into executable binaries, static libraries, or dynamic libraries using an LLVM backend. It implements a system based on result-based error handling, scoped memory pooling, and a semantic macro system. The compiler provides first-class support for hardware-backed SIMD vectors that map directly to processor instructions and enables runtime polymorphism through interface-based dynamic dispatch. The project covers a broad set of low-level capabilities, including manual and pooled memory management, inline assembly inte

This project is a localized educational resource for learning the Rust programming language, providing a comprehensive guide and technical specifications translated into Simplified Chinese. It serves as an instructional tool for studying language idioms, memory management, and type systems. The repository focuses on software documentation localization, converting official guides into Simplified Chinese to increase accessibility for non-English speakers. It utilizes a markdown-based system to organize content and supports multi-format export to static HTML, PDF, and EPUB formats for both web a

This project is a comprehensive educational resource and programming course covering C++ language semantics and features from C++03 through C++26. It provides structured tutorials and technical guides focused on modern C++ development. The material offers specialized instruction on template metaprogramming, including the use of type traits and compile-time computations. It features detailed guides on concurrency and parallelism for multi-core execution, as well as a reference for software design applying SOLID principles and RAII. Additionally, it covers build performance optimization to redu

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

Nim is a statically typed, compiled systems programming language designed for high performance and cross-platform development. It translates high-level source code into C, C++, or JavaScript, allowing developers to produce efficient native binaries or web-compatible scripts from a single codebase. The language emphasizes a clean, indentation-based syntax that simplifies code hierarchy while maintaining the power of a full-featured systems language. What distinguishes Nim is its robust metaprogramming framework, which allows developers to inspect, modify, and generate code structures during th

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

Roc is a statically typed, functional programming language built around immutable-by-default semantics, exhaustive pattern matching on tag unions, and a type system that combines optional explicit annotations with full compile-time type inference. Its core identity centers on correctness and expressiveness, using tagged unions for error handling with a question-mark operator for early error propagation, and a trailing-bang naming convention that makes side-effect boundaries syntactically visible at every call site. The language distinguishes itself through a platform-based I/O abstraction tha

This project is a collection of instructional resources and curriculum materials designed to teach the Java language. It provides a structured programming course, a fundamentals guide, and an object-oriented programming tutorial, supported by a series of practical coding exercises and implementation challenges. The curriculum focuses on implementing object-oriented patterns, including inheritance, polymorphism, and abstraction. It covers the creation of classes, the use of interfaces to define behavioral contracts, and the application of access modifiers to control data visibility. The educa

This is a TC39 proposal to add declarative pattern matching syntax to the ECMAScript language. It introduces a match expression that allows developers to inspect and branch on data structures using patterns with destructuring, guards, and logical combinators. The proposal defines a custom matcher protocol via a well-known symbol, enabling objects to implement user-defined matching logic with arbitrary extraction and decomposition. The proposal supports matching against literal primitives using SameValue equality with special handling for signed zero and NaN, as well as relational comparison

Coconut is a functional programming language that compiles to Python. It functions as a source-to-source compiler, translating high-level functional syntax into compatible Python code to maintain runtime compatibility. The language introduces a logic system for pattern matching and destructuring complex data structures. It provides a mechanism for tail call optimization to prevent stack overflow errors during deep recursive function calls and employs a lazy evaluation engine to defer computations until results are explicitly required. The project includes support for algebraic data types, pi

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

Dhall is a type-safe configuration language designed to create programmable configuration files that are guaranteed to terminate. It is a non-Turing-complete language that uses a strict type system to ensure correctness and prevent infinite loops during evaluation. The project functions as a deterministic configuration engine and marshalling tool, converting programmable expressions into static formats such as JSON, YAML, and Bash. It distinguishes itself through a focus on security and integrity, using semantic hashing to pin remote imports and enforcing origin policies to prevent data exfil

This project is an interactive programming education resource and tutorial designed for learning the Rust programming language and systems programming concepts. It provides a collection of runnable and editable code examples that serve as a practical reference for language syntax and implementation. The resource features an interactive code sandbox that allows users to execute and test code snippets in real time. It emphasizes the verification of technical accuracy by executing embedded code blocks during the build process to ensure all examples remain functional. The content covers a compre

This project is an educational resource designed for learning the Python programming language. It serves as a tutorial repository and programming guide, providing a collection of annotated scripts, code examples, and cheatsheets to help users master syntax and core fundamentals. The resource focuses on moving from basic language syntax to advanced implementation, with a particular emphasis on object-oriented programming, the use of the Python standard library, and scripting automation for business workflows. The content covers a broad range of programming capabilities, including control flow

pysheeet is a technical reference library providing a curated collection of code snippets and implementation patterns for advanced Python development, system integration, and high-performance computing. It serves as a comprehensive guide for implementing low-level network programming, native C extensions, and asynchronous and concurrent programming. The project provides specialized frameworks for the development and deployment of large language models, including tools for distributed GPU inference and high-performance serving. It also includes detailed patterns for high-performance computing

This project is a comprehensive educational resource consisting of a Bash programming tutorial, scripting reference, and Linux command line manual. It provides instructional materials for writing scripts, automating system tasks, and mastering terminal navigation and Unix system administration. The guides cover a wide range of shell environment customization, including prompt styling and the use of aliases. It also provides a shell environment guide for managing configuration files and initializing user environments. The materials detail a broad set of capabilities including control flow log

This project is a Chinese translation of a comprehensive guide to the Go programming language. It serves as a localized educational resource and technical manual designed to provide guidance on language syntax, design, and software development. The resource covers a broad range of Go language education, including the implementation of programming patterns and system design. It includes translated lessons and examples that focus on core language features such as concurrency and the use of interfaces. The content spans various capability areas, including language fundamentals, data modeling, r

Carp is a statically typed Lisp compiler that compiles Lisp-like syntax directly to C source code, enabling seamless integration with existing C libraries and low-level system programming. It manages memory deterministically at compile time using ownership tracking and linear types, eliminating garbage collection pauses and runtime overhead while ensuring type safety through an inferred static type system. The language distinguishes itself through compile-time macro expansion and metaprogramming capabilities, allowing code generation and transformation before final binary output. It enforces

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

This project is an open source discovery resource that provides curated lists of reusable code and libraries to help developers find technical solutions for specific tasks. It utilizes a category-based indexing system to organize diverse software tools by their functional capabilities. The repository is structured as a collection of markdown-based documentation and static content, serving as a directory for manual discovery and reference. The directory covers a wide range of capability areas, including cross-platform application development, cybersecurity tool creation, network protocol impl

Vyper is a security-focused, typed programming language and compiler designed for creating smart contracts that execute on the Ethereum Virtual Machine. It utilizes a Pythonic syntax to define contract logic and state, serving as a target for formal verification to allow for machine-checked proofs of correctness. The language distinguishes itself through strict architectural constraints that prioritize predictability and security. It enforces acyclic call graphs by prohibiting recursion and mandates bounded loops to ensure static gas prediction. Additionally, it features a native fixed-point

ClojureScript is a Lisp-based compiler and runtime that translates Clojure source code into JavaScript. It enables functional programming across different JavaScript engines and platforms, allowing developers to build user interfaces and applications for web browsers and server environments. The project provides a read-eval-print loop for executing code live within a browser or server for immediate feedback. This facilitates an interactive development workflow where code can be written and tested in real time without restarting the application. The system covers a broad capability surface, i

Opal is a Ruby frontend framework and compiler that translates Ruby source code into JavaScript. It functions as a web runtime that allows for the development of client-side web applications using Ruby instead of JavaScript. The project includes a Ruby HTML template engine that evaluates Ruby code embedded directly within markup files. It further integrates with JavaScript environments by bundling core libraries and dependencies into a distribution string for execution in a web browser. The system provides capabilities for Ruby to JavaScript compilation and the ability to encode and decode B

ReScript is a statically typed programming language and compiler designed to transform type-safe source code into efficient, human-readable JavaScript. It functions as a transpiler that enforces data consistency and prevents runtime errors through static type analysis for both web and server applications. The project distinguishes itself as an incremental build system that analyzes dependency graphs to recompile only modified files and their dependents. It includes a JSX compatible compiler for building user interfaces and provides a framework for bridging type-safe code with existing JavaScr

The Dart SDK is a comprehensive development kit for building cross-platform applications using a multi-paradigm programming language. It provides a unified toolchain that supports both just-in-time compilation for rapid development and ahead-of-time compilation for high-performance native machine code. The platform is built on a sound static type system and an isolate-based concurrency framework, which executes independent tasks in separate memory heaps to achieve parallelism without shared state contention. The SDK distinguishes itself through a versatile compilation pipeline that transforms