Projects sharing features with ChakraCore

Crafting Interpreters is a comprehensive resource for building a complete programming language from scratch. It provides a structured guide to the fundamental components of language implementation, including lexing, parsing, and the design of execution engines. The project demonstrates two distinct approaches to language execution: a tree-walking interpreter that evaluates source code by traversing its abstract syntax structure, and a stack-based virtual machine that compiles code into custom bytecode for execution. These implementations are supported by core runtime mechanisms such as lexica

V8 is a high-performance JavaScript and WebAssembly engine designed to compile and execute code within host applications. It functions as an embeddable scripting engine and just-in-time compiler, providing a portable library for integrating dynamic script execution into native software environments. The engine incorporates a WebAssembly runtime to execute compiled binary code for a stack-based virtual machine at near-native speeds. It enables native application scripting by allowing a JavaScript execution environment to be embedded directly into a native program to handle dynamic logic. The

Napajs is an embeddable JavaScript engine and multi-threaded runtime designed to be integrated directly into other software applications as a component. It serves as a parallel computation framework that allows JavaScript code to execute across multiple threads, bypassing the standard single-threaded event loop limitation to handle CPU-intensive tasks. The runtime is distinguished by its ability to load and execute modules from the NPM ecosystem and its pluggable execution environment. This architecture allows for custom implementations of memory allocation, system logging, and performance me

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

Pyston is a high-performance Python language implementation and JIT compiler. It functions as a runtime environment that executes Python code while maintaining compatibility with the standard language specification. The project accelerates execution by translating Python bytecode into native machine code during program execution. It utilizes a multi-tier compilation pipeline and adaptive execution optimization to transition from interpretation to compiled code based on runtime behavior. This implementation maintains binary compatibility with the standard Python C API to support native extensi

LuaJIT is a high-performance Lua language implementation and just-in-time compiler. It functions as an embedded scripting engine and dynamic binary translator that converts portable bytecode into native machine code during execution. The project focuses on high-performance scripting by translating bytecode into architecture-specific instructions to achieve execution speeds close to compiled C code. It utilizes a lightweight runtime environment designed for minimal memory overhead. The system supports binary data processing via bitwise operations and enables asynchronous task management throu

Just is a JavaScript runtime environment designed for system-level programming and high-performance execution. It provides a direct interface to kernel functions and hardware resources, allowing developers to interact with operating system features that are typically inaccessible through standard high-level programming environments. The runtime distinguishes itself by offering a streamlined execution model that minimizes startup latency and provides the ability to compile scripts into standalone, dependency-free binaries. By leveraging the V8 engine and a specialized module loading system, it

AsmJit is a runtime machine code generator and JIT compiler backend that translates high-level definitions into executable processor instructions. It provides a unified instruction emission API and an executable memory manager to allocate and protect virtual memory pages across multiple CPU architectures. The library functions as an assembly engine for x86 and ARM, supporting cross-platform assembly generation through a unified backend. It enables the creation of optimized machine code for different CPUs while maintaining a single codebase. The project covers low-level system abstractions in

Wasmtime is a WebAssembly runtime and sandboxed bytecode executor designed to run WebAssembly bytecode on a host system. It functions as an embeddable engine that integrates into applications through native APIs and language-specific bindings, as well as a standalone execution environment accessible via a command line interface. It is a WASI compatible runtime, implementing the WebAssembly System Interface to provide portable access to system resources. The engine utilizes a JIT compilation model to translate intermediate representation into optimized machine code for various CPU architecture

Luau is a high-performance programming language evolved from Lua 5.1. It consists of a bytecode virtual machine, an embeddable scripting engine, and a static code analyzer designed to provide a secure, sandboxed execution environment for host applications. The project is distinguished by its gradual typing system, which combines automatic type inference with optional manual annotations to detect bugs without requiring full static typing. It also features native vector mathematics for high-performance operations and a specialized debugging system that uses bytecode patching to minimize executi

This project is a technical reference and documentation suite focused on the internal architecture and operational principles of the Java Virtual Machine. It provides comprehensive guides and analysis on how the virtual machine manages class loading, memory organization, and bytecode execution. The documentation distinguishes itself by providing deep dives into specific runtime mechanisms, such as the binary decoding of class files, the hierarchical delegation model for class loaders, and the precise sequence of the loading, linking, and initialization lifecycle. It also details memory reclam

This project is a multi-language compiler collection and cross-platform toolchain used to translate source code from various programming languages into optimized machine code for different hardware architectures. It provides a suite of tools including an optimizing compiler backend, a machine code generator, and a comprehensive runtime library suite that implements necessary execution environments and support functions. The system utilizes a multi-pass compilation pipeline and pluggable language front-ends to process source code into intermediate representations. It distinguishes itself throu

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

llrt is a low-latency JavaScript runtime based on the QuickJS engine, specifically designed for executing asynchronous functions in serverless environments. It provides a lightweight execution layer optimized for fast startup times and minimal memory usage when running ES2023 workloads. The project differentiates itself by bundling natively optimized cloud service SDKs directly into the runtime binary to eliminate external dependency loading. To further reduce cold start latency, it implements parallel connection warming for TLS and network handshakes during the startup phase. The runtime co

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

Cello is a programming language extension for C that provides a higher-level implementation of the language. It integrates an object-oriented framework, an automated garbage collection system, and a runtime reflection library to enable dynamic type inspection. The project implements a structured system for object orientation within C, including support for classes, type classes, and polymorphism. It includes a runtime exception handling system to intercept execution errors and initiate recovery procedures. The framework further provides generic programming capabilities for creating reusable

Blink is a JIT-based instruction emulator and x86-64 Linux emulator designed to run Linux binaries and ELF files across different host operating systems and architectures. It functions as a binary execution sandbox and system call simulator, providing a controlled environment for running programs. The project distinguishes itself with a terminal user interface for monitoring execution, managing breakpoints, and visualizing JIT compilation paths. It supports self-modifying code through a cache-invalidating memory model and provides execution environment isolation using restricted directory ove

Node.js is an open-source, cross-platform JavaScript runtime environment built on the V8 engine, designed for executing JavaScript code outside a web browser. It operates as a server-side JavaScript platform with an event-driven, non-blocking I/O architecture that enables building scalable network applications and web servers. The runtime integrates the CommonJS module system for synchronous module loading and the npm ecosystem for sharing and reusing packages. The platform provides comprehensive capabilities for web server development, including creating HTTP and HTTPS servers, managing HTTP

QuickJS is a lightweight, memory-efficient JavaScript engine and runtime designed for embedding within C applications. It provides a small binary footprint and supports the latest ECMAScript standards, enabling the execution of JavaScript code with fast startup times and low memory usage. The project includes a standalone JavaScript compiler that transforms source code into independent binary executables. These files run on a machine without requiring an external language runtime. The engine implements deterministic memory management through reference counting and cycle collection. It also p

Otto is a Go implementation of a JavaScript interpreter and embedded scripting engine. It provides a runtime environment for executing JavaScript code within native applications and includes a parser that converts source code into an abstract syntax tree for analysis and processing. The project enables the creation of custom scripting interfaces by binding native Go functions into the JavaScript global scope. It also includes a utility to translate JavaScript regular expression patterns into compatible formats for other programming languages. The engine supports safe script sandboxing throug

Deno is a high-performance runtime for JavaScript and TypeScript that prioritizes security and developer productivity. Built on the V8 engine, it provides a secure execution environment that enforces a default-deny security model, requiring explicit user authorization for access to system resources like the file system, network, and environment variables. The runtime natively supports modern web-standard APIs, ensuring consistent behavior and portability across different environments. What distinguishes Deno is its integrated approach to the software development lifecycle. It bundles essentia

Boa is a high-performance JavaScript engine and parser designed to execute JavaScript code and analyze source code structure. It functions as a runtime environment for executing scripts to automate tasks or process data, providing both a command-line JavaScript interpreter and a tool for converting source code into abstract syntax trees. The engine is capable of compiling to WebAssembly, allowing the runtime to be deployed and executed within web browser environments. It includes an interactive read-eval-print loop for real-time logic testing and snippet execution via a terminal. The system

Wren is a bytecode-compiled, class-based scripting language designed as an embeddable programming language. It provides a lightweight runtime and interface for executing dynamic scripts directly within host software applications. The engine utilizes a single-pass compiler to transform source code into compact bytecode and a virtual machine to process those instructions. It supports concurrent task execution through a system of lightweight fibers and coroutines. The language implements a class-based object model with dynamic message dispatch for organizing code into reusable components. It al

QLExpress is a dynamic scripting engine and expression language for the Java platform. It functions as a runtime expression evaluator and business rule engine, allowing applications to execute scripts and evaluate business logic without requiring system recompilation. The engine distinguishes itself through a secure scripting sandbox that enforces security policies via class whitelisting and execution timeouts. It supports high-precision mathematics to prevent rounding errors and provides language alias support to create domain-specific languages that resemble natural language. Additional cap

workerd is a serverless edge runtime designed for executing lightweight, distributed functions at the network edge. It utilizes a V8-based JavaScript engine to provide fast startup and low memory overhead, while maintaining a WebAssembly-compatible execution environment that allows modules to run alongside JavaScript for high-performance computational tasks. The runtime supports isolate-based multi-tenancy to run multiple independent execution contexts within a single process. It implements an event-driven execution model that triggers code based on network requests or scheduled events and in

Unicorn is a multi-architecture CPU emulation framework and library that utilizes just-in-time compilation to execute instructions across various processor architectures, including ARM, x86, and RISC-V. It functions as both a JIT compilation engine and an instrumentation tool, allowing for the execution of machine code without the need for physical hardware. The framework is distinguished by its hook-based execution instrumentation, which enables the interception of specific instructions and memory accesses to trigger custom callback functions. It provides a language-agnostic binding layer an

Wren is an embeddable, class-based scripting language and bytecode interpreter. It provides a dependency-free virtual machine designed for integrating dynamic script execution into host applications via a C API. The language is centered on a modern object-oriented model featuring inheritance, method overloading, and first-class functions. It utilizes a concurrent fiber runtime to manage lightweight, cooperatively scheduled execution paths without relying on operating system threads. The project includes a comprehensive suite of object-oriented primitives, closure-based state capture, and a m