Open-source alternatives to Boa

JSHint is a JavaScript static analysis tool and linter designed to detect errors and enforce coding standards. It functions as a syntax validator that scans source code to identify potential logic problems and programming mistakes before the code is executed. The tool provides a command line interface for analyzing files and directories. It supports the export of analysis results into standardized formats such as Checkstyle for integration with external build tools. Analysis is managed through a system of linting rule management and environment global configuration. This includes the ability

UglifyJS2 is a suite of tools designed for parsing, beautifying, mangling, and minifying JavaScript code. It functions by converting source code into an abstract syntax tree to enable programmatic analysis and transformation, and it includes a dedicated generator for creating associated source maps. The project optimizes web production builds by compressing script logic and removing unreachable code. It utilizes name mangling to shorten variable and property names and implements a beautifier to reconstruct compressed scripts into a human-readable layout. The toolset covers broad capability a

RustPython is a Python 3 compatible interpreter implemented in Rust. It functions as a scripting engine that can be embedded directly into host applications, allowing for the execution of dynamic scripts and the customization of software behavior within a memory-safe environment. The project distinguishes itself through its ability to bridge Python and JavaScript runtimes, enabling data exchange and function invocation across language boundaries. It also provides a portable execution environment by compiling Python code into WebAssembly, which allows for the execution of logic directly within

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

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

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

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

syn is a Rust syntax tree parser and token stream converter. It serves as a toolkit for procedural macro development, providing a framework to parse Rust source code into structured syntax trees for analysis and transformation. The project enables the manipulation of Rust abstract syntax trees through specialized visitor and folder patterns for traversing and mutating nodes. It provides a bidirectional mapping that allows developers to convert token streams into structured trees and print those trees back into tokens for code generation. The library covers a broad range of syntax analysis ca

Binaryen is a WebAssembly compiler toolchain and optimizer designed to transform, validate, and shrink binary modules. It provides a comprehensive intermediate representation framework that converts binary code into a single-assignment form to enable advanced program analysis and code transformation. The project includes a specialized transformation engine that applies iterative optimization passes to increase execution speed and reduce binary size. Additionally, it functions as a transpiler that translates WebAssembly binary modules into executable JavaScript for environments that lack nativ

AssemblyScript is a compiler and tooling suite used for WebAssembly module development. It converts a subset of TypeScript syntax into binary modules to achieve high execution speeds and cross-platform binary execution. The project focuses on translating typed source code into the compact binary format required by WebAssembly runtimes. This allows for the movement of computationally heavy logic into binary modules for browser performance optimization and execution across different operating systems. The compilation process involves TypeScript-compatible syntax analysis and the generation of

Expr is a high-performance expression evaluation engine and language for Go applications. It functions as a dynamic rule engine that parses and executes custom logic and data validations at runtime without requiring the application to be recompiled. The system utilizes a sandboxed logic executor to run expressions without side effects. It ensures program termination by employing instruction-level loop detection to prevent infinite loops and isolates the evaluation process from the host system. The engine employs a bytecode-based virtual machine and abstract syntax tree analysis to achieve ex

This project is a suite of basic command line utilities rewritten in Rust, providing a cross-platform implementation of POSIX shell utilities. It serves as a portable CLI toolset designed to run across different operating systems and architectures. The implementation includes a WebAssembly shell environment, which allows these essential command line tools to be executed directly within a web browser without requiring a local installation. The toolset covers a broad range of system capabilities, including filesystem operations, text processing and stream editing, and system administration too

This repository contains the design specifications for WebAssembly, serving as a technical standard for portable low-level code. It defines the binary format, instruction set, and execution semantics required to ensure consistent behavior across different hardware platforms. The project establishes the framework for a language compilation target, detailing the requirements for translating high-level programming languages into a low-level binary format. It includes a security model that defines operational rules and safety goals for executing untrusted binary code. The specifications cover th

Esprima is a JavaScript parser that converts source code into a structured abstract syntax tree. It implements a specification-driven grammar to ensure compliance with ECMAScript standards, enabling the programmatic analysis and transformation of JavaScript programs. The project provides capabilities for lexical tokenization to break source code into individual symbols and static syntax validation to verify that scripts are well-formed without executing the code. Its functional surface covers JavaScript static analysis, lexical analysis, and the generation of abstract syntax trees.

TinyGo is a specialized compiler and development toolkit designed to bring the Go programming language to resource-constrained microcontrollers and WebAssembly environments. It provides a bare-metal runtime environment that enables high-level code execution without the need for a traditional operating system, utilizing an LLVM-based backend to generate efficient machine instructions. The project distinguishes itself through aggressive optimization techniques tailored for small hardware, including a static memory allocation strategy and whole-program dead code elimination that significantly re

Wasmer is a high-performance runtime engine designed to execute sandboxed WebAssembly modules across server-side, edge, and browser environments. It functions as a comprehensive platform for building, distributing, and running isolated applications, providing a secure and portable execution layer that maintains consistency across diverse hardware architectures and operating systems. The platform distinguishes itself through a robust toolchain that enables cross-language interoperability and the transformation of code into portable binary packages. It supports ahead-of-time binary generation t

PHP-Parser is a tool that converts PHP source code into an abstract syntax tree for static analysis and programmatic manipulation. It functions as a parser, a code generator, and a static analysis framework. The project enables the programmatic construction of abstract syntax tree nodes through a fluent interface and provides the ability to transform these trees back into formatted source code. It includes a serializer that exports abstract syntax trees to JSON format and reconstructs them from strings. The toolset covers several capability areas, including namespace resolution, constant exp

Expr is a statically typed expression engine and domain-specific language for parsing and evaluating dynamic logic strings within Go applications. It functions as a bytecode expression evaluator that executes compiled logic with guaranteed termination and memory safety. The engine utilizes a specialized compiler and virtual machine to achieve high-performance execution. It employs static type validation during the compilation phase to ensure operand compatibility and prevent runtime crashes. The project provides a data transformation engine capable of mapping, filtering, and aggregating coll

This project is a comprehensive manual and educational resource focused on the Babel compiler. It serves as a documentation guide and handbook for understanding the inner workings of JavaScript compilation, specifically regarding the transformation of source code. The material provides a technical walkthrough for developing custom plugins and extensions. It covers the process of creating tailored transformations to modify how JavaScript is parsed and generated. The content encompasses the broader JavaScript compilation workflow, focusing on abstract syntax tree manipulation, code generation,

GraalVM is a polyglot virtual machine and high-performance runtime designed to execute multiple programming languages within a single environment. It functions as a JVM language toolkit for building language implementations, a native image compiler for transforming bytecode into standalone binaries, and an execution environment for LLVM bitcode and WebAssembly modules. The project is distinguished by its polyglot interoperability framework, which allows different languages to share data and execution state with low overhead. It utilizes self-modifying abstract syntax trees to optimize languag

markdown-js is a JavaScript markdown parser and converter that transforms markdown text into HTML output. It functions as both a library and a command line interface tool for converting documents. The project is centered on an abstract syntax tree representation, allowing markdown to be parsed into a structured tree for programmatic inspection and modification before the final rendering process. This intermediate representation enables custom markup processing and document transformations. The toolset covers programmatic document parsing, static site generation, and CLI-based file processing

This project is an educational compiler implementation and a minimalist compiler construction tutorial. It serves as a practical example of how to build a functional compiler through a simplified end-to-end development process, transforming source code into executable instructions. The implementation is designed to teach the fundamentals of language implementation and compiler design. It focuses on the essential mechanics of transforming source code by demonstrating the core architecture of a translation process. The system covers the primary stages of compilation, including lexical analysis

Dongbei is a programming language that lets you write and run code using the vocabulary of the Northeastern Chinese dialect, translating those colloquial keywords into executable Python. It provides both a script execution mode for running saved .dongbei files and an interactive REPL for testing expressions line by line. The project distinguishes itself by making programming accessible and humorous through its dialect-based syntax, while also offering a debugging aid that prints the equivalent Python source alongside execution. Users can run complete programs from text files or experiment w

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

nom is a parser combinator framework for Rust used to build complex parsers by combining small, reusable parsing functions. It functions as a zero-copy parsing tool that minimizes memory overhead by returning slices of the original input instead of allocating new memory. The framework is designed for diverse data formats, serving as a binary data parser with configurable endianness and a bitstream processing library capable of extracting values of arbitrary bit length. It also functions as a streaming data parser that can process data arriving in chunks and signal when additional input is req

This project is a PHP implementation of a CSS selector engine that transforms CSS selector strings into compatible XPath expressions for locating elements within documents. It serves as a converter and expression generator that maps CSS selection logic to the XPath query language. The library processes selectors through a pipeline involving lexer-based tokenization and recursive descent parsing to create an abstract syntax tree. It utilizes pattern-matching logic to handle child and sibling relationships, translating CSS pseudo-classes and selectors into functional XPath logic. These capabil

Swift Evolution serves as the central governance and design platform for the Swift programming language. It provides a structured, collaborative framework for tracking, discussing, and managing the formal proposals and technical goals that define the language's syntax, semantics, and core features. By maintaining a comprehensive collection of design documentation, the project ensures the long-term stability and consistency of the language as it matures. The repository acts as the primary hub for the language's evolution, coordinating community feedback and technical decisions through a transp