Projects sharing features with Goja

This project is a JavaScript ES6 reference guide and syntax cheatsheet. It serves as an ECMAScript language guide providing technical examples and a curated list of tips for implementing modern JavaScript patterns. The guide covers a wide range of language features, including the use of classes for object blueprints, module systems for code organization, and arrow functions to preserve execution context. It provides instructions on utilizing block-scoped variables, template literals for string interpolation, and destructuring for nested data extraction. The reference also addresses asynchron

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

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

This project is a polyglot runtime bridge and interop framework designed to execute .NET and Node.js code within a single operating system process. It functions as a cross-runtime execution engine and in-process scripting host, enabling bidirectional communication and data exchange between the Common Language Runtime and JavaScript environments to eliminate cross-process communication overhead. The framework distinguishes itself by providing a system for bidirectional asynchronous callbacks and automatic data marshalling of binary buffers and serializable values between different managed obje

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

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

This project is an ECMAScript 2015 reference guide and JavaScript language cheat sheet. It provides a concise summary of the language specifications, syntax updates, and new features introduced in the 2015 standard. The guide serves as a technical overview of modern language patterns used to manage modular code structures and asynchronous operations. It functions as a reference for implementing current coding standards and studying core updates to the language. The content covers a wide range of capabilities, including asynchronous programming, object modeling, and module management. It deta

This project is a comprehensive JavaScript programming tutorial and language reference. It serves as a web development education resource providing instruction on modern language fundamentals, object-oriented design, and advanced asynchronous programming patterns. The resource functions as both a frontend development guide and a technical reference. It covers core language features such as closures, prototypes, promises, and typed arrays, while providing practical lessons on managing browser data and handling network requests. The content spans several key capability areas, including browser

This project is a comprehensive educational repository designed to help developers master the core mechanics, runtime behaviors, and browser-native capabilities of the JavaScript language. It provides a structured knowledge base that covers fundamental language features, such as prototype-based inheritance and event-loop-based concurrency, alongside advanced topics like JIT-compiled execution and memory management. The repository distinguishes itself by offering deep-dive technical guides that bridge the gap between abstract language concepts and practical browser implementation. It features

QuickJS is a lightweight, embeddable ECMAScript runtime that executes JavaScript programs conforming to the latest specification. It is designed as a compact, standards-compliant JavaScript engine suitable for resource-constrained environments and embedded systems, available both as prebuilt binaries and as source code that can be compiled for custom integration. The engine distinguishes itself through a minimal runtime footprint achieved by a single-pass compiler that produces compact bytecode, executed on a stack-based virtual machine. Memory management uses reference-counting garbage colle

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

Jint is a JavaScript interpreter for the .NET ecosystem that executes code without requiring a browser or Node.js environment. It is an ECMAScript compliant engine that provides a sandboxed scripting runtime with configurable limits on memory and time to run untrusted code. The engine features a native object bridge that exposes .NET classes and methods to JavaScript scripts for bidirectional data exchange. To reduce overhead during repeated executions, it utilizes a precompiled script cache to store parsed JavaScript in memory. The project covers asynchronous script execution and promise ha

wazero is a pure Go WebAssembly runtime that compiles and executes Wasm modules without CGO or any external dependencies. It provides a zero-dependency engine that runs on every Go-supported platform, including riscv64, making it a fully self-contained solution for embedding WebAssembly execution inside Go applications. The runtime offers two execution modes: an ahead-of-time compiler that translates WebAssembly modules into platform-specific machine code for near-native performance, and an interpreter that executes bytecode directly for maximum portability across architectures. Each module i

rusty_v8 is a Rust wrapper for the V8 JavaScript engine that allows for the embedding of a JavaScript runtime into native applications. It provides core components for managing engine bindings, memory allocation, sandboxed isolates, and the execution of WebAssembly modules. The project features a native host function bridge to map Rust functions to JavaScript objects and a dedicated memory allocator to manage thread-safe allocation and heap pressure. It includes a system for compiling and executing binary WebAssembly modules within the hosted native environment. The runtime covers capabiliti

Scriban is a .NET text templating engine and embedded scripting language used for dynamic text generation. It functions as an abstract syntax tree manipulation tool and a template parser, allowing for the conversion of scripts into visitable trees for analysis, modification, and rendering. The engine is specifically designed for Native AOT compatibility, utilizing a reflection-free API to execute templates in trimmed environments. It also provides a dedicated parser and conversion system for Liquid templates, enabling the migration and execution of Liquid scripts within .NET. The project cov

mQuickjs is a compact JavaScript engine designed for memory-constrained devices, such as microcontrollers, requiring as little as 10 KB of RAM and 100 KB of ROM. It achieves this through a fixed-buffer memory allocation scheme that avoids system heap usage, a compacting tracing garbage collector that eliminates fragmentation, and a ROM-embedded standard library that reduces both memory footprint and startup time. The engine compiles JavaScript source into portable bytecode that can be stored in persistent memory and executed without reparsing, and it emulates IEEE 754 floating-point arithmetic

Sol2 is a C++ Lua binding library that serves as a language interoperability layer for integrating Lua scripts into C++ applications. It acts as a scripting wrapper and API toolkit, enabling the execution of Lua code and the management of shared state within a native C++ environment. The library focuses on automated function and type mapping to bridge native C++ classes and complex data types with the Lua scripting engine. It provides mechanisms for bidirectional data exchange, allowing compiled logic and variables to be synchronized between the host application and the script runtime. The s

wasm-bindgen is a glue code generator and interoperability tool that facilitates high-level communication and data exchange between compiled Rust modules and JavaScript environments. It functions as a memory bridge and type definition generator, allowing the exchange of complex data types and the calling of functions across execution boundaries. The project distinguishes itself by automating the conversion of data types and function signatures using attribute-based bindings. It generates the necessary JavaScript and WebAssembly wrappers to manage linear memory mapping and creates automatic Ty

Positron is a data science integrated development environment and AI-powered code editor designed for polyglot development, specifically supporting Python and R. It functions as a remote compute workspace that separates the user interface from the execution kernel via SSH or container integration. The environment features a deep integration of large language models that provide context-aware suggestions and automated data analysis by accessing real-time interpreter state, in-memory objects, and plot outputs. It distinguishes itself through a polyglot runtime bridge that enables cross-language

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

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

WebViewJavascriptBridge is a communication layer for sending bidirectional messages between native Objective-C code and JavaScript within iOS and macOS web views. It serves as an interoperability toolkit for synchronizing data and executing callbacks between native Apple platform applications and their embedded web content. The project provides a messaging interface that exposes native functions to the web environment and triggers JavaScript handlers from native application code. It enables the registration of named handlers in native code that can be invoked by JavaScript to request device a

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

Rhino is a Java-based JavaScript engine that implements an ECMAScript compatibility layer for execution inside a Java virtual machine. It serves as an embedded scripting engine and a scripting bridge, allowing JavaScript code to be integrated and executed within Java applications. The project facilitates direct inter-language communication by mapping Java classes and objects into a JavaScript environment. This integration enables scripts to interact with internal system services and native host objects through a dedicated mapping mechanism. The engine optimizes performance by compiling JavaS

Hermes is a mobile-optimized JavaScript runtime and engine designed for React Native. It functions as an ahead-of-time bytecode compiler that converts JavaScript source code into a dense binary format during the build process to eliminate the need for parsing and compilation at runtime. The engine features a baseline JIT compiler that generates native machine code for frequently called functions to improve performance after the initial launch. It also includes a mobile-optimized garbage collector that precisely identifies reachable objects to minimize memory overhead and pause times on resour

xLua is a scripting bridge and C++ wrapper used to embed the Lua language into host applications. It facilitates bidirectional data exchange and function calls between scripts and the host environment. The project includes a runtime patching tool for replacing application logic and fixing bugs without requiring a system restart. It features a coroutine orchestrator that wraps asynchronous operations into linear code and a script validator that verifies digital signatures to ensure code authenticity and integrity before execution. To minimize memory overhead and garbage collection, the system

JSPatch is a JavaScript native bridge and method swizzler that allows for the dynamic injection of logic into a hosted native environment. It functions as a cross-language data mapper and execution engine, enabling the replacement of native function pointers with JavaScript wrappers to modify application behavior at runtime. The project provides the ability to perform runtime application patching by overriding native class methods and object properties. This allows for the modification of application logic and the application of hotfixes using JavaScript code loaded from local files or remote