Lib.rs

mlua

High level bindings to Lua 5.5/5.4/5.3/5.2/5.1 (including LuaJIT) and Luau with async/await features and support of writing native Lua modules in Rust

target-lexicon

LLVM target triple types

wasmtime-cranelift

Integration between Cranelift and Wasmtime

inkwell

aims to help you pen your own programming languages by safely wrapping llvm-sys

tree-sitter-lua

Lua grammar for tree-sitter

winch-codegen

Winch code generation library

ittapi

High-level Rust bindings for ittapi

wasmtime-internal-jit-icache-coherence

INTERNAL: Utilities for JIT icache maintenance

wasmtime-internal-winch

INTERNAL: Integration between Wasmtime and Winch

wasmtime-internal-jit-debug

INTERNAL: JIT debug interfaces support for Wasmtime

wasmer

High-performance WebAssembly runtime

linux-perf-data

A parser for the perf.data format and the jitdump format. These formats are used by the Linux perf tool.

rustpython

A python interpreter written in rust

tlua

Zero-cost high-level wrapper for Tarantool-LuaJIT

stylua

A code formatter for Lua

gccjit

Higher-level Rust bindings for libgccjit

fucker

BrainFuck interpreter and optimizing JIT compiler

rustpython-compiler

A usability wrapper around rustpython-parser and rustpython-compiler-core

zawk

An efficient Awk-like language implementation by Rust with stdlib

cranelift-module

Support for linking functions and data with Cranelift

steel-core

Core compiler and VM implementation for steel

luajit-src

Sources of LuaJIT 2.1 and logic to build it

vox-jit

Cranelift JIT backend for vox: compiled decode/encode stubs replacing the reflective interpreter

dynasmrt

runtime for assembling code at runtime. Combined with the plugin crate dynasm it can be used to write JIT compilers easily.

pharmsol

solving analytic and ode-defined pharmacometric models

cranelift-jit

A JIT library backed by Cranelift

rbpf

Virtual machine and JIT compiler for eBPF programs

fusevm

Language-agnostic bytecode VM with fused superinstructions and a 3-tier Cranelift JIT (linear, block, tracing with side-exits and frame materialization)

fory

Apache Fory: Blazingly fast multi-language serialization framework with trait objects and reference support

cranelift

Umbrella for commonly-used cranelift crates

closure-ffi

FFI utility for creating bare function pointers that invoke a closure

wasmtime-jit-icache-coherence

JIT icache maintenance

lua-astra

🔥 Blazingly Fast 🔥 runtime environment for Lua

xlsynth

Accelerated Hardware Synthesis (XLS/XLSynth) via Rust

lux-lib

lux package manager for Lua

wasmtime-cranelift-shared

Base-level integration with Wasmtime and Cranelift

lux-cli

A luxurious package manager for Lua

dynasm

A plugin for assembling code at runtime. Combined with the runtime crate dynasmrt it can be used to write JIT compilers easily.

jit-cli

A CLI for fetching JIRA issue summaries, details, and current sprint tickets

rustpython-codegen

Compiler for python code into bytecode for the rustpython VM

runmat-hir

High-level IR for RunMat with type inference and lowering utilities

luavisors

A minimal process supervisor for containers using Rust and Lua

oxieml

EML operator: all elementary functions from exp(x) - ln(y)

rustpython-vm

RustPython virtual machine

cljrs

clojurust CLI — run, repl, compile, and eval

jstime

JS Runtime

theseus-mlua

High level bindings to Lua 5.4/5.3/5.2/5.1 (including LuaJIT) and Luau with async/await features and support of writing native Lua modules in Rust. Fork with added Factorio Lua support

wasmtime-internal-cranelift

INTERNAL: Integration between Cranelift and Wasmtime

cranelift-codegen

Low-level code generator library

regexr

A high-performance regex engine built from scratch with JIT compilation and SIMD acceleration

ferrotorch-jit

Tracing JIT compiler and graph optimizer for ferrotorch

elf_loader

A high-performance, no_std compliant ELF loader and JIT linker for Rust

airl-cli

Command-line interface for AIRL: run, compile, type-check, patch, REPL, HTTP API

wasmtime-jit-debug

JIT debug interfaces support for Wasmtime

tensorlogic-infer

Execution and autodiff traits for TensorLogic inference engines

wasmtime-jit

JIT-style execution for WebAsssembly code in Cranelift

splintr

Fast Rust tokenizer (BPE + SentencePiece + WordPiece) with Python bindings

symjit

a lightweight just-in-time (JIT) optimizer compiler

runmat-filesystem

Swappable filesystem abstraction for RunMat hosts (native, wasm, remote)

tidepool-repr

Intermediate representation for the Tidepool compiler

raden

2D Vector Graphics Library

sile

Simon’s Improved Layout Engine

cortexflow-cli

CortexFlow command line interface made to interact with the CortexBrain core components

wasmtime-winch

Integration between Wasmtime and Winch

runmat-gc-api

Public API types for the RunMat garbage collector

cubecl-std

CubeCL Standard Library

pybevy

Python Real-Time Engine Built on Bevy

wasmer-compiler-singlepass

Singlepass compiler for Wasmer WebAssembly runtime

rustpython-doc

Python __doc__ database for RustPython

ristretto_vm

Java Virtual Machine

maray

JIT Ray Tracing using basic math

elworthy

JIT compiler that specialises Bismut-Elworthy-Li formulas into SIMD kernels for unbiased Monte Carlo Greeks on non-stationary SDEs

zust-vm

Cranelift JIT runtime for executing Zust modules

rustpython-common

General python functions and algorithms for use in RustPython

mlua-periphery

A Rust-native implementation of lua-periphery for mlua

rustpython-sre_engine

A low-level implementation of Python's SRE regex engine

mlua-extras

Extra helpers and functionality built on top of mlua for embedded lua development

pcre2

High level wrapper library for PCRE2

unluac

Multi-dialect Lua decompiler written in Rust

hypothalamus

An optimizing Brainfuck AOT compiler with an LLVM IR backend

runmat-telemetry

Shared telemetry schema for RunMat runtime events

bevy_mod_scripting

Multi language scripting in Bevy

runmat-thread-local

Cross-platform thread-local storage helpers for RunMat (native and wasm)

runmat-vm

RunMat virtual machine and bytecode interpreter

runmat-turbine

Cranelift-based JIT compiler for RunMat - the optimizing tier of our V8-inspired execution model

fidget

Infrastructure for complex closed-form implicit surfaces

runmat-lexer

Lexer for the RunMat language (MATLAB/Octave syntax) built with logos

qwen3-vl

vision-language structured-output engine over mistralrs, implementing the engine-agnostic llmtask::Task contract

strykelang

A highly parallel Perl 5 interpreter written in Rust

samply

A command line profiler for macOS and Linux

runmat-parser

Parser for RunMat (MATLAB/Octave) producing HIR from token streams

mono-rt

Dynamic bindings to the Mono runtime for process injection into Unity games and Mono-hosted applications on Windows

runmat-builtins

RunMat built-in functions and standard library components

vox-jit-cal

Runtime calibration of opaque std container layouts for the vox JIT

servo-config

A component of the servo web-engine

luaskills

core runtime library for loading, invoking, and managing Lua skill packages

runmat-time

Cross-platform time utilities for RunMat (monotonic + wall-clock helpers)

runmat-async

Shared async runtime error types and host I/O interaction primitives for RunMat

stator_jse_ffi

Stator JavaScript engine — stable C FFI layer for embedding

ferrotorch

PyTorch in Rust — deep learning framework built on ferray

facet-postcard

Postcard binary format for facet with Tier-0 and Tier-2 JIT deserialization

gorgeous

Grammar-driven pretty printers auto-generated from BBNF grammars

wasmtime-internal-cranelift-rwasm

INTERNAL: Integration between Cranelift and Wasmtime

kyu-common

Shared error types, IDs, and configuration for the KyuGraph database

rustx_core

A clean, minimal scripting language that seamlessly integrates with Rust

arm64jit

Spec-driven AArch64 JIT assembler for Rust

beadie

Hot-function promotion broker for interpreter-to-JIT tiering

ristretto_jit

JVM JIT Compiler

xlsynth-prover

XLS formal pProvers

lust-rs

A WIP Lua-like scripting language implemented in Rust, designed for embedding and rapid scripting with a strong type system, with trace-based JIT

runmat

High-performance MATLAB/Octave syntax mathematical runtime

cambridge-asm

Run pseudoassembly from Cambridge International syllabus 9618

rusthrust

GPU parallel algorithms library inspired by NVIDIA Thrust

bamboo-core

Vietnamese input method engine written in Rust

burn-cubecl

Generic backend that can be compiled just-in-time to any shader language target

rustorch-core

Core tensor library for RusTorch

ruchyruchy

JIT Compiler + Advanced Debugging Tools - Cranelift-based JIT with mixed-mode execution, eBPF syscall tracing, statistical profiling, 10 quality tools, automated bug detection, 95%+ detection rate…

rumus

A native-Rust deep learning framework with explicit memory safety and hardware acceleration

awkrs

Awk implementation in Rust with broad CLI compatibility, parallel records, and experimental Cranelift JIT

gccjit_sys

Raw bindings to libgccjit. Companion to the gccjit crate.

mlua-socket

A Rust-native implementation of LuaSocket for mlua

jitvm

a tiny i64-only language with a bytecode interpreter and a hand-rolled x86-64 jit

forge-lang

Forge — Internet-native programming language with natural syntax, bytecode VM, and built-in HTTP/database/crypto

jit-core

Core AArch64 encoder engine for arm64jit

runmat-config

Shared configuration schema and loaders for RunMat

machina-core

Core IR definitions, CPU traits, and address types for the Machina RISC-V emulator

ascent-interpreter

Interpreter and JIT for Ascent Datalog programs

lucia-lasm

LASM - Lucia Assembly Language

rustx-lang

A clean, minimal scripting language that seamlessly integrates with Rust

kyu-executor

Vectorized query executor with optional Cranelift JIT for KyuGraph

lambda-expr

evaluating string expressions in hot loops

factorio-mlua

High level bindings to Lua 5.4/5.3/5.2/5.1 (including LuaJIT) and Roblox Luau with async/await features and support of writing native Lua modules in Rust. Fork with added Factorio Lua support

facet-msgpack

MsgPack binary format for facet

tailwind-css

Compile tailwind short instructions to css

pandrs

A high-performance DataFrame library for Rust, providing pandas-like API with advanced features including SIMD optimization, parallel processing, and distributed computing capabilities

cranelift-reader

Cranelift textual IR reader

kyu-graph

High-performance embedded property graph database with Cypher query support

omnia

Ergonomic WebAssembly component runtime built on wasmtime with pluggable WASI host services

jvmrs

A JVM implementation in Rust with Cranelift JIT, AOT compilation, and WebAssembly support

gaia-jit

JIT execution primitives for Gaia project

jit-assembler

A multi-architecture JIT assembler library for runtime code generation

morok-codegen

Backend code generation for the Morok ML compiler

rustpython-jit

Experimental JIT(just in time) compiler for python code

cljrs-compiler

JIT (Cranelift) and AOT compiler backend for clojurust

dsp56300

assembler, disassembler, and JIT emulator

tidepool-bridge

Bridge between Rust types and Tidepool Core values

stator_jse

Stator JavaScript engine core — parser, bytecode compiler, Maglev JIT, interpreter, GC

cortexflow_identity

CortexFlow identity service package

patchouly

A copy-and-patch JIT framework in Rust

dynarmic-sys-mythrax

Rust wrapper for the Dynarmic ARM dynamic recompiler — Mythrax fork of dynarmic-sys with Windows MSVC build fixes (mman shim + MSVC link directives) and TPIDRRO_EL0 / emu_start overflow corrections

hexodsp

Comprehensive DSP graph and synthesis library for developing a modular synthesizer in Rust, such as HexoSynth

panproto-core

Core re-export facade for panproto

jit-codegen

Code generator for arm64jit instruction metadata

r2g_mlua

High level bindings to Lua 5.4/5.3/5.2/5.1 (including LuaJIT) and Roblox Luau with async/await features and support of writing native Lua modules in Rust

tidepool

Compile Haskell effect stacks to Cranelift JIT, drive from Rust

azure_mgmt_solutions

generated REST API bindings

cw-wasmer

High-performance WebAssembly runtime

glua_parser

Parser for Garry's Mod Lua, Lua 5.x, and LuaJIT source files

sigil-parser

Parser and native compiler for the Sigil programming language

runmat-ignition

Baseline interpreter for RunMat enabling instant startup and execution

phprs

A PHP interpreter with build/package manager written in Rust

solverang

Domain-agnostic numerical solver for nonlinear systems and least-squares problems

ryft

A Framework for Tracing, Automatic Differentiation, and Just-In-Time Compilation

alpaca-broker-client-rs

Open brokerage accounts, enable stock, options and crypto trading. Manage the ongoing user experience and brokerage customer lifecycle with the Alpaca Broker API

jmon-rs

A zero-copy, cross-platform JVM monitoring library (similar to jstat) in Rust

hclua

torsh-fx

Graph-based model representation and transformation for ToRSh

airl-compile

Cranelift JIT compiler and WASM backend for AIRL IR

just-engine

A ground-up ES6 JavaScript engine with tree-walking interpreter, bytecode VMs, and Cranelift JIT compiler

evalexpr-jit

JIT compilation and symbolic differentiation of evalexpr expressions with Cranelift

torsh-utils

functions and helpers for ToRSh

edlc_lsp

EDLc Language Sever Protocol implementation

ordo-core

High-performance rule engine with JIT compilation, visual editor support, and database filter push-down

deno_ffi

Dynamic library ffi for deno

mlua-crc16

A Rust-native implementation of LuaRocks youlu/luacrc16 for mlua

lower-ir-utils

Helpers for mapping Rust types to Cranelift JIT signatures, lowering call arguments, and reducing module boilerplate

ittapi-sys

Rust bindings for ittapi

torsh-jit

JIT compilation and kernel fusion for ToRSh deep learning framework

qudit-expr

Accelerated and Extensible Quantum Library

cljrs-logging

Feature-gated debug/trace logging for clojurust

b3

port of B3 WebKit codegen backend

runmat-static-analysis

Domain-specific static analysis passes for RunMat

dfajit

JIT compilation of DFA transition tables to native x86_64 jump tables

mogi_run_program

CLI to run binaries in MOGI

ruby

Pure Rust implementation of Ruby runtime environment

diffsol-c

A diffsol wrapper featuring runtime scalar/matrix/solver types and a C API

wmlua

tidepool-optimize

Optimization passes for Tidepool Core

facet-format-postcard

Postcard binary format for facet with Tier-0 and Tier-2 JIT deserialization

symjit-bridge

a bridge bwtween Symjit compiler and Symbolica CAS

runmat-kernel

Jupyter kernel implementation for RunMat using ZeroMQ and the Jupyter protocol

flg

A linux profiling utility

shape-jit

Tiered JIT compiler (Cranelift) for the Shape virtual machine

squid

A RISC-V emulator with AOT compilation for fuzzing

machina-accel

JIT acceleration engine: IR optimization, register allocation, x86-64 code generation, and TB execution

scheme-rs

Embedded scheme for the Rust ecosystem

frawk

an efficient Awk-like language

tidepool-runtime

Runtime support for Tidepool applications

facet-format-msgpack

MsgPack binary format for facet using the Tier-2 JIT architecture

whitespacers

A whitespace JIT-compiler, for when your whitespace just isn't executing fast enough

wscript-cli

CLI runner for Wscript

dynarmic-sys

wrapper for the Dynarmic ARM dynamic recompiler

kajit

A facet-based JIT for (de)serializing Rust values real fast

cubecl-ir

Intermediate representation for CubeCL

rocalang

A contractual language for the AI era

tabulon

A high-performance, JIT-compiled expression evaluation engine using Cranelift

morok-runtime

Kernel execution runtime for the Morok ML compiler

tidepool-heap

Memory management and heap layout for Tidepool Core

tidepool-effect

Effect system and handlers for Tidepool Core

fidget-jit

Native JIT compiler for Fidget

axonml-jit

JIT compilation for Axonml tensor operations

synoema-types

Synoema — programming language optimized for LLM code generation

synoema-parser

Synoema — programming language optimized for LLM code generation

synfx-dsp-jit

DSP JIT (Just In Time compiled) engine for real time audio synthesis and effects for Rust

aarchmrs-instructions

AARCHMRS-generated ARM instructions functions

xlsynth-sys

Accelerated Hardware Synthesis (XLS/XLSynth) via Rust (Native Library)

dsp56300-emu

DSP56300 JIT emulator

lightbeam

An optimising one-pass streaming compiler for WebAssembly

bpfjit-sys

Rust bindings to NetBSD's cBPF JIT engine

tidepool-codegen

Cranelift-based JIT compiler for Tidepool Core

synoema-core

Synoema — programming language optimized for LLM code generation

cmajor

Rust bindings for the Cmajor JIT engine

synoema-eval

Synoema — programming language optimized for LLM code generation

ebpfkit

Kernel-Space eBPF Just-In-Time Pipeline Filter Compiler

panproto-jit

LLVM JIT compilation of panproto expressions for accelerated data migration

cubecl-linalg

CubeCL Linear Algebra Library

predicator

allows the creation, loading, and unloading of Rust and other language plugins on the fly using LLVM's ORC JIT

synoema-lexer

Synoema — programming language optimized for LLM code generation

copy/v86

x86 PC emulator and x86-to-wasm JIT, running in the browser

kafe

Deserialization using kajit

synoema-diagnostic

Synoema — programming language optimized for LLM code generation

pezsc-executor-wasmtime

Defines a WasmRuntime that uses the Wasmtime JIT to execute

beadie-llvm

LLVM JIT backend adapter for beadie (via inkwell)

jit-spec

Arm AArch64 spec parser and model for arm64jit

beadie-cranelift

Cranelift JIT backend adapter for beadie

mir-rs

FFI bindings to MIR Project (https://github.com/vnmakarov/mir)

synoema-repl

Synoema — programming language optimized for LLM code generation

macroassembler

writing portable x86-64/riscv64/aarch64 assembly code in Rust

flow_compiler

JIT and AOT compiler for the Flow programming language using Cranelift

mijit

Experimental JIT compiler generator

baracuda-nvjitlink

Safe Rust wrappers for NVIDIA nvJitLink (CUDA 12.0+ JIT linker)

emei

JIT/AOT backend codegen framework

llvm-alt

A wrapper for LLVM, a powerful library and toolkit for compilers

jit-allocator

An executable code allocator

avr-vm

VM with JIT-compiler for ATMega32

barfs

Befunge JIT

nusy-cranelift

V13: Graph-native Cranelift JIT frontend — CodeNode → CLIF IR

libtcc

Rust binding for libtcc

jstime_core

JS Runtime

pcre2-sys

Low level bindings to PCRE2

aarchmrs-types

AARCHMRS common types

bfjit

Brainfuck JIT VM tutorial

cranefack-cli

Commandline utility for the cranefack brainfuck compiler

dynasm-lib

A pure rust assembler, not a JIT. Used within direct-asm for maximum control over assembly.

mogi_cpu

CPU emulation core for MOGI

beadie-core

Bead chain, broker, hotness policy, swap, and deopt — no JIT backend

wasmer-singlepass-backend-x

Wasmer runtime single pass compiler backend

cranelift-preopt

Support for optimizations in Cranelift

jit-allocator2

An executable code allocator. Fork for jit-allocator

cranelift-simplejit

JIT library backed by Cranelift

machinecode

Execute machine code in hex form

wasmer-singlepass-backend

Wasmer runtime single pass compiler backend

wasmer-engine-jit

Wasmer JIT Engine

sc-executor-wasmtime

Defines a WasmRuntime that uses the Wasmtime JIT to execute

llvm-rs

A wrapper for LLVM, a powerful library and toolkit for compilers

wasmer-clif-backend

Wasmer runtime Cranelift compiler backend

wasmer-singlepass-backend-near

Wasmer runtime single pass compiler backend

ano_jit_bfi_rs

Outdated Just-In-Time BrainFuck Interpreter written in RuSt

ordo-derive

Procedural macros for the Ordo rule engine — #[derive(TypedContext)] for schema-aware JIT