Open-source alternatives to Janet

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

mruby is a lightweight Ruby interpreter designed to be embedded into C applications. It compiles Ruby source code into a compact, platform-independent bytecode that executes on a register-based virtual machine, and exposes a stable C API for host programs to initialize the interpreter, load bytecode, and invoke Ruby methods at runtime. The interpreter distinguishes itself through a tightly coupled parser and compiler that performs lexical analysis, syntax parsing, and bytecode generation in a single pass without constructing an intermediate AST, minimizing memory overhead. It also includes a

Hy is a Lisp implementation for Python that allows for writing Lisp syntax which compiles to Python bytecode. It operates as a Python-based Lisp dialect and S-expression language, providing full access to the Python standard library and ecosystem. The language focuses on macro-based metaprogramming, featuring an AST-walking macro system and reader macros that allow for custom syntax transformations and parsing rules. It enables the manipulation of the abstract syntax tree to extend language capabilities. The project includes a read-eval-print loop for interactive development and supports sta

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

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

Gevent is a Python coroutine concurrency library and asynchronous task manager designed for high-concurrency I/O tasks. It provides a cooperative networking framework for building asynchronous TCP, UDP, and HTTP servers, as well as a WSGI web server implementation for hosting web applications. The project is distinguished by its standard library monkey-patching tool, which replaces blocking synchronous functions with cooperative versions to enable asynchronous behavior in third-party code. This allows for a cooperative multitasking workflow where the system yields execution during I/O waits t

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

Amp is a non-blocking concurrency framework for PHP. It provides a core infrastructure for writing asynchronous applications using an event loop to schedule operations, timers, and signals within a single process. The project implements a coroutine library that utilizes fibers to suspend and resume function execution. This allows the system to handle concurrent tasks without blocking the main execution thread, optimizing CPU usage during input and output operations. It further manages pending operation results through a future and promise implementation. The framework covers a broad range of

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

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

Torch7 is a scientific computing environment and tensor computation library used for deep learning research and numerical analysis. It functions as a Lua-based framework for training neural networks and learning agents, providing a toolkit for implementing architectures and training through reinforcement learning algorithms. The project is distinguished by its tight integration with C, utilizing a binding layer to map high-level scripting to low-level C structures for direct memory access. It supports hardware-accelerated computation by offloading linear algebra and convolution operations to

Rhai is an embedded scripting engine and dynamically typed language designed for integration into Rust applications. It functions as an abstract syntax tree compiler and native interop layer, allowing developers to map Rust types and functions into a scripting environment for bidirectional communication. The project serves as a framework for creating customizable domain-specific languages. It allows for the definition of custom operators, syntax, and restricted execution environments, enabling the creation of specialized languages with tailored functional sets. The engine covers a broad rang

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 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

Red is a programming language with a native compiler that translates high-level source code into standalone executables for Windows, macOS, and Linux without external runtime dependencies. It combines a cross-platform GUI development framework that renders native operating system widgets from a single codebase with a reactive data binding system that automatically synchronizes UI state with data sources. The language also includes an embedded DSL and parsing engine based on PEG grammar rules for defining and processing domain-specific languages within the language itself. The project distingu

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

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

ChakraCore is an embedded JavaScript engine designed to be integrated as a library within a host application. Its primary purpose is to provide a programmable scripting layer and a lightweight runtime environment for executing JavaScript code and managing state via a programmatic interface. The project focuses on bridging high-level scripting with low-level system calls through a C API. This allows developers to implement custom scripting engines and embed JavaScript execution directly into applications to enable task automation and functional extensions. The engine utilizes a bytecode-based

This project provides a framework for binding Rust and Python, enabling the creation of native extension modules and the embedding of the Python interpreter within host applications. It functions as a cross-language interoperability library that facilitates the execution of scripts, the definition of classes, and the sharing of data structures across the boundary of the two runtimes. The framework distinguishes itself through the use of procedural macros to automate the generation of boilerplate code, simplifying the process of exposing native functions and data types. It employs type-level m

Quasar is a JVM concurrency framework that implements the actor model and a lightweight thread library. It provides isolated execution units that communicate via asynchronous message passing to eliminate shared mutable state. The project distinguishes itself through a distributed actor system capable of operating across multiple cluster nodes with location-transparent registries and actor state migration. It utilizes a work-stealing fiber scheduler to manage millions of lightweight threads, allowing tasks to suspend during non-blocking I/O operations without stalling underlying system threads

Pest is a Rust parsing library and automatic parser generator that transforms formal grammar definitions into functional parsers. It specializes in Parsing Expression Grammar to recognize and structure complex text patterns, providing a system for context-free grammar parsing. The library implements zero-copy tokenization and static grammar compilation to reduce runtime overhead. It supports no-std runtime compatibility, allowing the parser to be compiled for embedded or bare-metal environments where a standard library is unavailable. The project covers a range of parsing capabilities, inclu

Gopher-lua is a complete implementation of the Lua language and its standard libraries written natively in Go. It serves as an embedded scripting engine and virtual machine that allows Go applications to execute Lua scripts and exchange data between the host and the script environment. The project provides a bytecode compiler to transform source code into a binary format for faster execution. It enables deep integration between the two languages by allowing the registration of native Go functions to be called from scripts, and the invocation of script functions directly from Go. The engine c

Wasm3 is a WebAssembly interpreter designed for embedded runtime integration. It enables the execution of portable binary logic on microcontrollers and resource-constrained hardware, providing support for modules that utilize the WebAssembly System Interface to interact with system resources. The runtime employs register-based bytecode interpretation and direct-threaded dispatch to map virtual registers to physical CPU registers. It includes a host-call interface to map imports to C functions and utilizes static module validation to ensure bytecode follows specification rules before execution

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

ES6-for-humans is an educational resource and technical manual providing a structured tutorial and programming guide for the ECMAScript 2015 language standards. It serves as a reference for transitioning from legacy JavaScript to modern syntax and coding patterns. The project covers modern language constructs including block-scoped variables, arrow functions, and class hierarchies. It provides guidance on implementing functional programming patterns via generators and lexically scoped functions, as well as object-oriented design using prototype-based inheritance. The documentation covers asy

JerryScript is a lightweight, ECMAScript-compliant JavaScript engine and bytecode compiler designed for resource-constrained devices. It serves as an embedded interpreter and IoT scripting runtime, enabling the execution of JavaScript code within native C applications on hardware with limited memory. The project differentiates itself through a focus on low-memory runtime management, utilizing bytecode precompilation and pre-compiled state snapshots to reduce startup time and memory overhead. It features a C-binding native bridge for bidirectional communication between native code and scripts,

This project is a comprehensive technical guide to advanced Go programming. It serves as a programming guide, technical reference, and textbook covering low-level optimization and distributed systems architecture. The resource provides detailed instructions on writing assembly instructions to optimize performance-critical code and managing C-Go interoperability to bridge C libraries with Go. It also functions as a manual for implementing remote procedure call mechanisms and creating custom plugins for the Protocol Buffers compiler. The material covers high-level capabilities including the de