Open-source alternatives to Rav1e

sudo-rs is a low-level system utility and privileged command executor written in Rust. It provides a memory-safe implementation of sudo and su for running programs with superuser or alternate user permissions and switching session privileges to other local user identities. The project integrates with kernel security modules to function as a sandboxed process launcher, restricting system resources and process capabilities during execution. The utility includes support for multi-language system localization, utilizing compiled message catalogues to provide translated user interface text based

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

wasm-pack is a build tool and workflow orchestrator for compiling Rust code to WebAssembly. It coordinates the compilation process and generates the JavaScript glue code required to execute Rust logic within web browsers and server-side runtimes. The tool manages binary optimization to reduce file sizes and improve execution speed. It also functions as a package manager, bundling compiled WebAssembly modules into archives compatible with JavaScript registries and bundlers. The project covers language interoperability through the automatic generation of TypeScript type definitions. It further

LibSass is a high-performance Sass to CSS compiler implemented as a native C++ engine. It transforms style sheets written in a pre-processor language into standard CSS. The project provides a C language application binary interface that allows the compilation engine to be embedded into different programming languages. It features a modular architecture that supports extending compilation logic through a shared-library plugin system. The engine handles style sheet resolution and uses a multi-stage process to parse source text into an abstract syntax tree before emitting the final CSS output.

Linfa is a classical machine learning framework and statistical learning suite implemented in Rust. It provides a collection of algorithms for supervised and unsupervised learning, focused on traditional statistical methods such as regression, clustering, and decision trees. The toolkit is distinguished by its ability to be compiled into WebAssembly, enabling analytical models to execute within browser environments. It employs a trait-based algorithm interface to standardize the process of training and prediction across its various models. The library covers a broad range of capabilities, in

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

Trunk is a WebAssembly build tool and orchestrator designed to automate the process of transforming Rust source code into deployable web applications. It serves as a frontend bundler that packages WebAssembly binaries along with HTML and static assets for browser deployment. The system utilizes an HTML-driven build orchestration model, using the index HTML file as the primary configuration source to determine entry points and dependencies. It integrates with the Rust compiler and associated toolchains to transform code into optimized binaries and glue code. The tool provides a development en

Scala.js is a compiler and cross-platform language toolchain that transforms Scala source code into JavaScript or WebAssembly. It functions as a statically typed tool for the JavaScript ecosystem, enabling the development of applications for web browsers and Node.js environments. The project serves as a JavaScript interop framework, allowing the creation of type-safe facades and bindings to interact with external libraries and global objects. It provides mechanisms for both static and dynamic JavaScript invocation, including the generation of TypeScript bindings and the ability to export inte

CameraView is a high-level Android camera library and hardware wrapper designed for capturing photos and videos. It provides an abstraction layer for managing camera hardware and a media capture API for recording high-resolution video and RAW photos with configurable bitrates and resolutions. The project features a real-time camera filter framework and a preview manager. These systems allow for the application of custom shaders and visual effects to live camera streams and the rendering of previews with customizable aspect ratios, overlays, and composition grids. The library covers a wide ra

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

Vugu is a Go WebAssembly UI library and framework used to build type-safe, component-based single-page applications. It functions as a single-file component framework that bundles markup, styles, and logic into modular units, utilizing a virtual DOM engine to synchronize state changes with the browser output. The project features a Go component generator that converts custom UI templates into executable Go source code at compile time. It distinguishes itself through a WebAssembly-based runtime that executes application logic as a compiled binary in the browser and a server-side rendering tool

Pigo is a computer vision library written in Go for locating human faces in images and video streams. It provides tools for face detection, facial landmark identification, and pupil and eye localization. The project is implemented in pure Go to ensure portable execution without external dependencies. It supports compilation to WebAssembly, enabling face detection and image processing to run directly in web browsers without a backend. The library's capabilities include real-time face detection using classifier cascades and gaze tracking localization. It maps anatomical points on the face to a

Porffor is an ahead-of-time compiler that converts JavaScript and TypeScript source code into native machine code or C binaries. It functions as a native binary generator and transpiler, producing standalone executable files that do not require a runtime or virtual machine. The project translates source code into C language files and WebAssembly binary formats. It includes a direct-to-binary pipeline for TypeScript, allowing for the generation of target executables without a separate transpilation step to JavaScript. The toolset also includes an interactive read-eval-print loop for real-time

Walt is a transpiler and typed language that converts a JavaScript-like syntax into WebAssembly binary format. It functions as a toolchain for developing high-performance logic for browsers and runtimes by translating typed source code into WebAssembly text format. The project includes a bundler-integrated loader that automates the recompilation of source files during the build process. It provides a linear memory manager used to define custom data layouts, structs, and memory allocators within a contiguous heap. The language supports defined function signatures, numeric types, and the abili

Trunk is a build tool and development server for compiling Rust code to WebAssembly and packaging it for browser deployment. It functions as a web bundler that combines WebAssembly modules, JavaScript, and static files into a deployable web application. The tool provides a local development server utilizing HTTP and WebSocket proxies to enable rapid iteration. This environment includes a file-system watcher that triggers automatic rebuilds and browser reloading when source files are modified. The pipeline handles the conversion of Rust source code into WebAssembly binaries and generates the

Panel is a Python data application framework used to build interactive dashboards and reactive user interfaces by connecting data visualizations, widgets, and callbacks. It functions as a reactive UI library that synchronizes application state with interface updates based on user interactions. The project distinguishes itself by offering multiple execution models, including a FastAPI-based web application server for scalable session management and a WebAssembly compiler that enables Python applications to run directly in the browser without a backend server. It also includes a specialized too

TeaVM is a Java bytecode transpiler and browser-based JVM runtime that converts compiled Java class files into JavaScript or WebAssembly. It functions as a compiler and build pipeline tool that enables applications written in various JVM languages to execute natively within a web browser. The project distinguishes itself by transforming bytecode directly into optimized web formats without requiring the original source code. It includes a WebAssembly bytecode compiler for high-performance execution and a specialized emulation system to handle asynchronous multithreading within the single-threa

Motionity is a browser-based motion graphics editor and video compositor. It provides a visual timeline for creating animated videos and compositions using a layer-based system and keyframe animation tools. The project features a dedicated Lottie animation renderer, allowing users to import and render vector-based files for scalable motion graphics. It includes specialized tools for keyframe animation, using easing functions to control object movement and property transitions. The platform covers a broad range of production capabilities, including digital asset composition, video clip editin

json-to-go is a web-based tool for automatically generating Go structs from JSON input. It functions as a JSON to Go type generator, transforming unstructured JSON data or API responses into strongly typed source code structures. The project employs a WebAssembly-based translation engine to run the Go type generator directly within the browser. This architecture utilizes a schema-inference engine and recursive type mapping to analyze nested JSON objects and determine the appropriate Go data types for fields and arrays. The tool also includes utilities for API client development, allowing use

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

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

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

hashsigs-rs is a Rust cryptography library providing a hash-based signature scheme and a library for generating and verifying one-time digital signatures. It serves as a smart contract signature verifier designed to validate identity and authenticity within on-chain environments. The project implements one-time signature generation and verification to ensure that digital signatures are valid for a single message, preventing key reuse. It supports blockchain authentication workflows and cryptographic identity proofs for validating senders without relying on external servers. The library utili

This project provides a foundational template and boilerplate structure for developing games with the Bevy engine in Rust. It is designed to facilitate cross-platform development by offering a unified codebase that targets desktop, mobile, and web environments. The template distinguishes itself through pre-configured automation pipelines that handle the complexities of multi-platform build orchestration. It includes integrated workflows for continuous integration, allowing developers to validate code compatibility and stability across various operating systems and hardware architectures autom

Chrono is a multi-physics simulation suite that functions as a multibody dynamics simulator, a finite element analysis tool, and a robotics simulation framework. It provides specialized solvers for fluid-solid interaction and distributed physics engines capable of synchronizing multiple agents across a network. The project features a dedicated pipeline for converting CAD assemblies into simulation-ready formats and integrates directly with robot operating systems to validate autonomous control logic and sensors. It differentiates itself through the use of WebAssembly for portable browser-base

node-gyp is a build system wrapper and compilation tool designed to transform C and C++ source code into binary modules for the Node.js runtime. It functions as a native module compiler that orchestrates the process of converting native source code into binary bindings for high-performance execution. The project provides cross-platform compilation by managing different compilers and SDKs across Windows, macOS, and Linux. It translates a single project configuration into platform-specific build files, such as Makefiles or Visual Studio projects, to ensure consistent builds across different ope

RmlUi is a cross-platform UI renderer and middleware library that enables the creation of user interfaces using a subset of HTML and CSS. It functions as a rendering-agnostic layer designed to integrate web-standard layout and styling into custom game engines and embedded applications. The framework is distinguished by its integration of Lua for dynamic logic and control, as well as a specialized toolkit for rendering SVG images and Lottie animations. It utilizes a pluggable rendering backend that decouples geometry generation from the final display, allowing it to generate textured geometry