Projects sharing features with Just

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

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

Goja is a JavaScript engine and ECMAScript compliant interpreter implemented entirely in Go. It serves as an embedded scripting engine that allows Go applications to execute JavaScript code and integrate a programmable scripting layer without relying on Cgo or external native dependencies. The project functions as a bridge between Go and JavaScript, enabling bidirectional data exchange and function invocation. It allows Go hosts to expose native structs, slices, and maps as JavaScript objects and arrays, while providing mechanisms to export script values and functions back into native Go type

This project is a technical reference and a collection of internal analysis notes focused on the Go language runtime and compiler. It provides a detailed breakdown of the language internals, covering memory management, garbage collection, and the execution model of the scheduler. The material distinguishes itself by providing deep dives into low-level system details, including a reference for Go assembly instructions, register usage, and system call interfacing. It specifically analyzes the internal implementation of concurrency primitives, such as the goroutine scheduling mechanism, channel

FrankenPHP is a high-performance application server and runtime for PHP. It functions as a web server that executes PHP scripts and delivers web content, incorporating a binary bundler to package applications and their dependencies into standalone executable files. The project integrates the PHP interpreter directly into the Caddy web server to provide automatic HTTPS and flexible site configuration. It features a worker mode runtime that keeps applications bootloaded in memory across requests to eliminate bootstrap overhead and increase throughput. Additionally, it serves as a communication

Mage is a build automation tool and workflow orchestrator that uses Go functions to define executable build targets instead of a custom domain-specific language. It functions as a compiled build system and task runner, mapping exported Go functions to command-line targets. The tool distinguishes itself by compiling build definitions into static binaries for distribution to dependency-free machines. It utilizes hashed binary caching to avoid redundant compilations and supports the packaging of the runtime and defined tasks into a single standalone executable. The platform covers dependency ma

Cosmopolitan is a cross-platform C runtime library and build framework that enables the creation of single-file, self-contained executables. By providing a unified set of system headers and a specialized compiler toolchain, it allows developers to write low-level systems code that executes natively across multiple operating systems without requiring recompilation for each target environment. The project utilizes a polyglot binary format and a system call shimming layer to intercept and translate kernel requests, effectively bypassing standard library dependencies. This approach consolidates a

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

FrankenPHP is a Go-based PHP runtime and application server that integrates a web server and PHP interpreter to host applications without requiring a separate process manager. It functions as a worker mode server that keeps applications in memory across requests to eliminate bootstrap overhead and a static binary bundler that packages applications and the server into a single self-contained executable. The project distinguishes itself by allowing the embedding of a PHP runtime directly into Go programs and enabling the development of PHP extensions using the Go language. It also includes a bu

CppGuide is a curated collection of educational resources and practical guides focused on C++ server development, Linux kernel internals, concurrent programming, network protocols, and security exploitation. It provides structured learning paths for backend developers, covering everything from interview preparation to building high-performance network servers and understanding operating system fundamentals. The guide distinguishes itself by offering in-depth, hands-on tutorials that walk through real-world implementations, including building a Redis-like server from scratch, designing custom

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

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

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

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

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

This project is a cross-platform mobile framework that enables the development of native iOS and Android applications from a single codebase. It utilizes a declarative component-based model where developers define user interfaces using a syntax extension that maps directly to underlying platform-native view primitives. By decoupling application logic from the host platform's main thread, the framework maintains a consistent native view hierarchy while ensuring that JavaScript execution remains independent of UI rendering. The framework distinguishes itself through a robust bridge architecture

Script is a collection of scripts and rule-sets designed for iOS proxy tools to modify mobile application behavior, filter network traffic, and automate interactions with online services. It provides a library of scripts and a network filter to manage how applications communicate with web services. The project enables the unlocking of premium features, memberships, and VIP content within third-party applications. It also allows for the bypass of geographical restrictions on downloads and the removal of advertisements from mobile application interfaces. The toolset covers the automation of we

Gecko-dev is a web browser engine and cross-platform browser framework. It serves as a foundational system for rendering web content and executing JavaScript, providing a complete layout and rendering pipeline to transform web markup into visual pixels. The project is distinguished by a specialized browser UI toolkit that uses XML-based languages and custom widgets to build cross-platform windows and menus. It incorporates unique development bridges, including design-to-code linking and a standardized protocol for AI-driven browser control and automated verification. Its broader capabilities

Unreal.js is a JavaScript runtime and scripting layer for Unreal Engine that embeds the V8 engine to implement game logic and manage application state. It provides a bridge for writing high-level application behavior and actor control without modifying the core engine source code, as well as a framework for extending the Unreal Engine editor with custom interface elements. The project distinguishes itself through a V8-based integration that supports real-time code reloading and live iteration, allowing scripts to be updated without restarting the application. It includes a bidirectional commu

RoboMongo is a cross-platform database manager and graphical interface for administering MongoDB databases. It serves as a shell integrated development environment and query tool for managing NoSQL data stores and exploring collections across multiple server instances. The application provides a visual environment for writing and executing modern JavaScript scripts and native shell commands. It includes capabilities for running aggregate queries with paginated results and supports side-by-side views for comparing data outputs. The tool covers remote database connectivity through SSH tunnelin

AutoJs6 is an Android automation framework and JavaScript runtime designed to automate user interface interactions and system tasks on mobile devices. It functions as a UI automator that inspects screen hierarchies and manipulates on-screen controls via selectors to automate manual workflows. The project includes an Android script compiler that bundles automation scripts into standalone APK files for distribution. It also provides a remote debugging tool that creates a network-based bridge between a mobile device and a desktop IDE for writing and testing scripts. The framework covers a broad

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 is a framework for building native macOS desktop applications. It serves as a desktop port of a cross-platform mobile framework, providing a development environment and a native UI library to create software using native system frameworks and a component-based architecture. The framework enables the development of native macOS applications by integrating a JavaScript-based workflow with macOS system-level frameworks. It facilitates cross-platform UI development by allowing logic and design patterns to be shared across different operating systems while maintaining native desktop i

react-native-windows is a framework and rendering system used to build native desktop applications for Windows using React. It functions as an extension that brings a mobile-first development model to the Windows desktop environment, mapping React components directly to native Windows interface elements. The project enables the creation of desktop software through a declarative component-based architecture. It integrates React Native projects into the Windows ecosystem by translating components into native user interface elements rather than using web views. The framework covers cross-platfo

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 cross-platform mobile animation library and UI thread animation engine designed to create high-performance animations by running JavaScript logic directly on the UI thread. It functions as a multi-threaded JavaScript runtime that allows code to execute across multiple threads to improve concurrency and prevent frame drops. The library focuses on enabling fluid user interface interactions and high-frame-rate transitions that remain stable regardless of the main processing load. It provides a system for offloading animation logic from the main thread to ensure smooth motion an

Dokploy is a self-hosted platform-as-a-service designed to simplify the deployment and management of containerized applications and databases. It provides a centralized control plane that decouples administrative management from application workloads, allowing users to oversee infrastructure across multiple server nodes through a unified web interface or a command-line tool. The platform distinguishes itself through an extensive library of pre-configured application templates, enabling the rapid deployment of databases, identity providers, and various productivity or development tools. It sup