-
rustc-demangle
Rust compiler symbol demangling
-
ariadne
A fancy diagnostics & reporting crate
-
tree-sitter
Rust bindings to the Tree-sitter parsing library
-
rquickjs
High level bindings to the QuickJS JavaScript engine
-
boa_engine
Boa is a Javascript lexer, parser and compiler written in Rust. Currently, it has support for some of the language.
-
llvm-sys
Bindings to LLVM's C API
-
ena
Union-find, congruence closure, and other unification code. Based on code from rustc.
-
oxc
A collection of JavaScript tools written in Rust
-
apollo-parser
Spec-compliant GraphQL parser
-
melior
The rustic MLIR bindings in Rust
-
demand
A CLI prompt library
-
jaq-interpret
Interpreter for the jaq language
-
cel
A parser and interpreter for the Common Expression Language (CEL)
-
c2rust
C to Rust translation, refactoring, and cross-checking
-
gluon
A static, type inferred programming language for application embedding
-
boa_string
Boa is a Javascript lexer, parser and compiler written in Rust. Currently, it has support for some of the language.
-
rustpython
A python interpreter written in rust
-
cranelift-frontend
Cranelift IR builder helper
-
mago-syntax
A correct, fast, and memory-efficient PHP syntax implementation, including Lexer, Parser, AST, and utilities for Mago
-
luna-core
Pure-Rust Lua runtime (interpreter only, zero third-party dependencies). The JIT-equipped variant lives in the
luna-jitcrate. -
sus_compiler
Compiler for the SUS Hardware Design Language
-
rune
Language, an embeddable dynamic programming language for Rust
-
brillig
bytecode ACIR uses for non-determinism
-
rolldown-ariadne
A fork of github.com/zesterer/ariadne
-
fucker
BrainFuck interpreter and optimizing JIT compiler
-
typst-assets
Assets for the Typst compiler
-
clang
A somewhat idiomatic Rust wrapper for libclang
-
gccjit
Higher-level Rust bindings for libgccjit
-
rustlr
Bottom-Up Parser Generator with Advanced Options
-
starlark
language in Rust
-
egglog
language that combines the benefits of equality saturation and datalog. It can be used for analysis, optimization, and synthesis of programs. It is the successor to the popular rust library egg.
-
miden-project
Interface for working with Miden projects
-
spirt
Shader-focused IR to target, transform and translate from
-
rustc-std-workspace-core
integration of crates.io crates into rust-lang/rust standard library workspace
-
steel-core
Core compiler and VM implementation for steel
-
jstime
JS Runtime
-
rilua
Lua 5.1.1 implemented in Rust, targeting the World of Warcraft addon variant
-
hstr
A string type which is optimized for hash operations
-
erg
programming language
-
rustpython-compiler
A usability wrapper around rustpython-parser and rustpython-compiler-core
-
harn-parser
Parser, AST, and type checker for the Harn programming language
-
tishlang_compile
Tish native compiler backend
-
tket
Quantinuum's TKET Quantum Compiler
-
hvm
A massively parallel, optimal functional runtime in Rust
-
php-rs-parser
Fast PHP parser producing a typed AST
-
typespec_client_core
Client runtime for TypeSpec-generated libraries
-
spirv-cross2
Safe Rust bindings to SPIRV-Cross
-
python-rs
A stackless Python 3 interpreter written in Rust — academic/hobby AI-assisted port of CPython. Pre-release; not usable yet.
-
cljrs-ir
Intermediate representation types for clojurust compiler and interpreter
-
ternpkg
Package manager for the ternlang ecosystem — ternlang.toml manifest, GitHub-backed registry, install/list/info commands
-
bock
language compiler and CLI — feature-declarative, target-agnostic programming language with AI-native transpilation
-
buildlang
(buildc): an effects-oriented compiler with a verified C path, shader output, experimental backends, opt-in linear types, and re-checkable accountability + scientific-runtime receipts
-
cranelift-native
Support for targeting the host with Cranelift
-
tinymist-package
Tinymist package support for Typst
-
monty
A sandboxed, snapshotable Python interpreter written in Rust
-
badc
A quick, slim cross-platform C compiler (also a compiler-as-library) (C99, C11, and more) with a JIT and native ELF / PE / Mach-O backends
-
mago-docblock
Analyzes PHP docblocks to extract annotations, tags, and documentation comments, aiding tools that rely on inline documentation
-
typst-pdf
PDF exporter for Typst
-
boa_parser
ECMAScript parser for the Boa JavaScript engine
-
dynasmrt
runtime for assembling code at runtime. Combined with the plugin crate dynasm it can be used to write JIT compilers easily.
-
chalk-ir
Chalk's internal representation of types, goals, and clauses
-
diplomat-runtime
Common runtime utilities used by diplomat codegen
-
midenc-log
flexible trace logging for midenc
-
decy-hir
High-level Intermediate Representation for C-to-Rust transpilation
-
rustc-build-sysroot
Build a rustc sysroot with custom flags
-
lex-types
Type system + effect inference for Lex
-
gust-cli
The Gust compiler CLI — compile .gu state machine files to Rust, Go, WASM, no_std, or C FFI
-
cranelift-isle
ISLE: Instruction Selection and Lowering Expressions. A domain-specific language for instruction selection in Cranelift.
-
sqry-lang-java
Java language plugin for sqry
-
brink-cli
CLI for compiling and running ink stories
-
frg
Compiled programming language with frogs!
-
slicec
The Slice parser and other core components for Slice compilers
-
hsml
A pug-inspired HTML preprocessor
-
codesnake
Pretty printer for non-overlapping code spans
-
axon-lsp
Language Server Protocol server for the Axon programming language. Deterministic diagnostics, hover, completion, and go-to-definition across VSCode, Claude Code, Cursor, Antigravity…
-
garnish_lang_compiler
Utilites to compile garnish scripts
-
chap
easy to learn, interpretive, scripting language written in Rust
-
dylint-link
A wrapper around Rust's default linker to help create Dylint libraries
-
vrl
Vector Remap Language
-
monkey-gc
QuickJS-style GC runtime for Monkey (bytecode VM with cycle collector)
-
codewandler-flux-lang
Flux-Lang: the pure language core — AST, renderer, analyzer, effect/op types, a Rust eDSL, and the schema/skill single-source-of-truth. No runtime, provider, or concrete tools.
-
ferrugocc
An experimental C compiler and obfuscating compiler written in Rust, targeting x86_64 SysV ABI
-
obeli-sk-boa-ast
Abstract Syntax Tree definition for the Boa JavaScript engine
-
mollify-parse
Python parsing for Mollify, built on Astral's ruff_python_parser/ruff_python_ast behind parser-agnostic types (see ADR-0001)
-
fsqlite-planner
Query planner: name resolution, WHERE analysis, join ordering
-
jsonpiler
a Json syntax programming language for Windows
-
rustc_version_runtime
querying the version of the rustc compiler used in runtime
-
rustc_utils
working with the Rust compiler
-
assura
Contract-first AI-native language. Write what it should do. AI proves it does.
-
keleusma
Total Functional Stream Processor with definitive WCET and WCMU verification, targeting no_std + alloc embedded scripting
-
logicaffeine-compile
LOGOS compilation pipeline - codegen and interpreter
-
heraclitus-compiler
Compiler frontend for developing great programming languages
-
haskelujah
A Haskell compiler in Rust — GHC-compatible, self-contained, faster than GHC
-
run
a.k.a. runtool: the bridge between human and AI tooling
-
cudaforge
Advanced CUDA kernel builder for Rust with incremental builds, auto-detection, and external dependency support
-
forgellm-cli
CLI tool for the ForgeLLM compiler
-
maslc
Maduka Authorization Specification Language (MASL) toolchain and runtime
-
pyo3-introspection
Introspect dynamic libraries built with PyO3 to get metadata about the exported Python types
-
somni-expr
An expression evaluation library
-
nectar-lang
A compiled-to-WASM frontend language with built-in security, SEO, and mobile support
-
rusty_lr
A Bison-inspired parser generator and compiler frontend framework for Rust, with IELR(1), LALR(1), GLR, and LSP support
-
luaur-code-gen
Native (A64/X64) code generation for Luau (Rust)
-
oxc_parser
A collection of JavaScript tools written in Rust
-
atlas_77
Wannabe systems programming language
-
firmion
Ergonomic firmware and binary file creation tool
-
nexus-lang
A programming language for generating component network descriptions
-
kataan
A high-performance JavaScript engine written in pure Rust. Library, C FFI, and CLI.
-
rumoca
Modelica compiler written in RUST
-
onion-lang
A modern functional programming language with asynchronous execution and lazy evaluation
-
lady-deirdre
Compiler front-end foundation technology. Main Crate.
-
pfcl-lsp
PFCL language server — diagnostics, catalog completion, and hover over the standard load pipeline
-
seq-compiler
Compiler for the Seq programming language
-
xlsynth
Accelerated Hardware Synthesis (XLS/XLSynth) via Rust
-
dusk-lang
Compiler for the dusk programming language, a systems language with generational memory safety, emitting textual LLVM IR
-
wadl
parser for Rust
-
viperjs
An embeddable JavaScript engine in safe Rust, with zero runtime dependencies
-
stak-vm
Virtual machines for Stak Scheme
-
scryer-prolog
A modern Prolog implementation written mostly in Rust
-
packtab
Pack static integer tables into compact multi-level lookup tables
-
cxxbridge-flags
Compiler configuration of the
cxxcrate (implementation detail) -
monkey-asm
AOT AArch64 assembly backend for monkeylang (Linux ELF and macOS Mach-O)
-
cljrs-reader
Lexer and parser producing Form AST nodes for clojurust
-
delo
A statically typed, compiled-to-C programming language that can time-travel
-
rspack_plugin_rsc
Rspack React Server Component plugin
-
typeset
A DSL for defining source code pretty printers
-
runmat-gc
Generational garbage collector for RunMat with optional pointer compression
-
pandora-interpreter
A command-line tool to run pandora language
-
fusevm
Language-agnostic bytecode VM with fused superinstructions and a 3-tier Cranelift JIT (linear/block/tracing)
-
r2u2_cli
R2U2 CLI: A stream-based runtime monitor command-line interface
-
blisp
A lisp like statically typed programing language for no_std
-
python-ast
compiling Python to Rust
-
pliron
Programming Languages Intermediate RepresentatiON
-
cranelift-jit
A JIT library backed by Cranelift
-
node_resolver
Node.js module resolution algorithm used in Deno
-
kz80_lisp
A minimal LISP interpreter and compiler for RetroShield Z80
-
lamina
High-performance compiler backend for Lamina Intermediate Representation
-
sema-lang
Sema — a Lisp dialect with first-class LLM primitives
-
lumen-lang
Lumen — a dynamic, bytecode-compiled programming language with a bytecode VM, generational GC, and a full toolchain
-
three_body_lang
Three Body Language written in Rust
-
quickjs_runtime
Wrapper API and utils for the QuickJS JavaScript engine with support for Promise, Modules, Async/await
-
rhai-loco
Rhai scripting engine integration for Loco
-
encore-toolchain
Compiler and bytecode VM for Fleche, a functional language with first-class continuations
-
wesley-cli
Wesley native CLI
-
mata-ll
command-line compiler and runner: compiles a Haskell subset to Lua and runs it via an embedded Lua interpreter
-
junocc
Compiler for JunoLang
-
adana
namespaces aliases for command lines & basic scripting language
-
tl-parser
Recursive descent parser for ThinkingLanguage
-
tdsl-core
Core IR and lowering logic for the Timeline DSL compiler
-
bhc-hir-to-core
HIR to Core IR lowering for BHC
-
zetac
The final systems language
-
asc_bin
An automated C/C++ package manager, source code scanner, and builder that streamlines dependency management, enhances code analysis, and simplifies the build process
-
mimium-lang
mimium(minimal-musical-medium) an infrastructural programming language for sound and music
-
acir_field
The field implementation being used by ACIR
-
fable
Tiny typed language over Facet-reflected Rust values, lowered toward Weavy IR
-
vyre
GPU compute intermediate representation with a standard operation library
-
teacat
A modern document languge for web pages
-
semantic-analyzer
Semantic analyzer library for compilers written in Rust for semantic analysis of programming languages AST
-
rasm-core
Core of RASM x86_64 assembler
-
syn-locator
A source mapper for syn syntax trees
-
bhc-parser
Parser for Haskell 2026 source code
-
tulisp
An embeddable lisp interpreter
-
nyxstone
Bindings for the nyxstone assembler/disassembler
-
sora-codegen
powerful configuration table compiler for games and data-heavy tools
-
zust-dynamic
Dynamic value model for Zust scripts, with JSON, MessagePack, bytes, and typed vectors
-
metaslang_stack_graphs
Stack graphs utilities used in Slang
-
pipeline-script
Script engine designed for the project construction tool pipeline(crate name pipeline-cli)
-
lambda_mountain
Typed Macro Assembler (backed by Coq proofs-of-correctness)
-
wdl-ast
An abstract syntax tree for Workflow Description Language (WDL) documents
-
qala-compiler
Compiler and bytecode VM for the Qala programming language
-
vexilc
The Vexil schema compiler CLI
-
patch-prolog-frontend
Tokenizer and parser for patch-prolog2 (compiler-side only)
-
rajac
Command-line interface for the rajac Java compiler
-
graphcal-plugin-host
Type-safe, unit-aware, Git-friendly reactive programming language for engineering calculations
-
loopkit
The Loop Language compiler — validates skill repositories against the Loop Language spec
-
soppo
Compiler for Soppo, a Go superset with enums, pattern matching, and nil safety
-
diplomat
FFI generation macro
-
dust_dds_gen
OMG IDL compiler for Dust DDS
-
calcit
Interpreter and js codegen for Calcit
-
vize_relief
Relief - The sculptured AST surface for Vize Vue templates
-
relon-analyzer
Semantic analysis layer for the Relon language: name resolution, schema desugar, diagnostics
-
from-pest
Convert from a pest grammar to a typed AST
-
alephc
Aleph Compiler (or transpiler)
-
vbrcc
A small C compiler with a hand-written x86-64 assembler and PE/COFF backend
-
tishlang_bytecode
Bytecode compiler for Tish (AST → bytecode)
-
rex-engine
Rex: A strongly-typed, pure, implicitly parallel functional programming language
-
ion-core
Embeddable scripting language with a bytecode VM
-
tidepool-repr
Intermediate representation for the Tidepool compiler
-
kn-cuda-eval
A CUDA executor for neural network graphs
-
hiko-harness
part of the hiko ML-family scripting language
-
caixa-ast
Span-aware Lisp AST for the caixa ecosystem — shared by caixa-fmt, caixa-lint, caixa-lsp. Compatible with tatara-lisp's Sexp.
-
aver-lang
VM and transpiler for Aver, a statically-typed language designed for AI-assisted development
-
libcint
FFI binding and GTO wrapper for libcint (C library)
-
seq-core
Core runtime library for stack-based languages (Value, Stack, Channels)
-
rnsc
RNS assembler/compiler CLI for the Lagertha VM project
-
harn-kernel
Portable compiler, program artifact, and deterministic execution kernel for Harn
-
tket-qsystem
TKET tool for preparing and validating
Hugrs for compilation targeting Quantinuum H-series quantum computers -
beamr
runtime with the BEAM's execution model, targeting Gleam
-
qbe
QBE IR for Rust
-
smelt-hir
Shared high-level IR (HIR) types and validation for the Smelt transpiler
-
bbnf-ir
Canonical Grammar IR for the BBNF compiler pipeline
-
lift-quantum
LIFT compiler quantum dialect: qubits (linear types), quantum gates, noise attributes, layout mapping
-
java_asm
Java bytecode reader & writer in rust
-
rune_c_compiler
A Rune to C source file compiler
-
gabelang
A high level, interpretted and garbage collected programming language
-
nextjs_react_compiler_hir
Rust port of the React Compiler, vendored from facebook/react
-
ty-backend_t
Ty to T compiler (monomorphization and lowering)
-
airlang
Air is a universal, reliable, and lean programming language
-
mago-names
Resolves and normalizes identifiers (classes, functions, constants) within PHP code
-
speccy
Heads over the spectrum core. For now: a themed terminal (TUI) head via the display pipeline.
-
faye
a pretty lil lisp
-
ascent
Logic programming in Rust
-
glslang
Rust bindings to glslang
-
deno_webidl
WebIDL implementation for Deno
-
uiua
A stack-based array programming language
-
progenitor-middleware
An OpenAPI client generator
-
lang-util
implementing parsers and ASTs using lalrpop
-
clue
C/Rust like programming language that compiles into Lua code
-
nl-compiler
Verilog frontend compilation into a memory-safe netlist IR
-
whisper-lang
Whisper: a compact stack-based programming language for AI
-
csml_engine
The CSML Engine is a conversational engine designed to make it extremely easy to create rich and powerful chatbots
-
cedar-policy-symcc
Symbolic Cedar Compiler (SymCC): translates queries about Cedar policies to SMT
-
rustcc
An little C Complier( now it's just WIP :) )
-
somatize-compiler
Graph-to-execution-plan compiler for the Soma runtime
-
t-backend_c
C code generator for the T programming language
-
hi-doc
Diagnostics formatting library
-
reluxscript
Write AST transformations once. Compile to Babel, SWC, and beyond.
-
phper
The framework that allows us to write PHP extensions using pure and safe Rust whenever possible
-
sbnf
A BNF-style language for writing sublime-syntax files
-
tsbytes
Compile TypeScript directly to native JVM bytecode and executable JARs
-
urd
Dialogue scripting language for games — compiler, VM, and static analysis
-
runar-compiler-rust
Rúnar compiler (full pipeline: .runar.ts → Bitcoin Script)
-
formalang
compiler frontend: lexer, parser, semantic analyzer, and IR lowering
-
sapphire-lang
Gradually typed scripting language where every value is an object and types are optional, checked at runtime
-
pluto-lang
A interpreted programming language made in Rust
-
deft-quick-js
QuickJS Javascript engine wrapper
-
nagami
Shrinks WGSL shaders via Naga IR optimization passes
-
atoxide-cli
Atopile compiler CLI
-
netsblox-ast
parsing NetsBlox project files into an AST for use in code generation
-
zust-parser
Lexer and parser for the Zust scripting language
-
passerine
A small extensible functional scripting language designed for concise expression with little code
-
hax-frontend-exporter
mirrors of the algebraic data types used in the Rust compilers, removing indirections and inlining various pieces of information
-
dolang-private-util
Shared utilities for Do language crates
-
tket-json-rs
Serializable definition of TKET circuits and operations
-
maat
programming language -- Rust-native syntax for writing zero-knowledge proofs
-
cargo-ats3
Cargo subcommand for ATS3 projects
-
han-lang
한글(Han) Korean-syntax programming language: interpreter, LLVM-IR codegen, and LSP
-
generic-lang
A Lox based programming language
-
garble_lang
Turing-Incomplete Programming Language for Multi-Party Computation with Garbled Circuits
-
typst-render
Raster image exporter for Typst
-
neorusticus
A Prolog implementation in Rust with enhanced error handling
-
Tres
Interpreter for the Tc2 esolang
-
xlog-cuda
CUDA kernel provider, buffers, and interop for XLOG
-
bhc-lower
AST to HIR lowering for BHC
-
pe-assembler
PE/COFF assembler for Windows instruction sets - strongly typed, object-oriented, zero-dependency core
-
glt
Glint compiler library
-
haskelujah-driver
Compilation driver and project orchestration for the Haskelujah compiler
-
mech
programming language for building reactive systems like robots, games, and animations
-
midenc-dialect-wasm
Miden IR Wasm Dialect
-
loom-lang
Loom — a programming language for safe-by-construction software. Recipes with first-class effects, refinement types, and a zero-dep Loom → Rust → rustc → run pipeline.
-
airl-cli
Command-line interface for AIRL: run, compile, type-check, patch, REPL, HTTP API
-
oonta
OCaml (subset) to LLVM IR compiler front-end
-
a2x
A converter from ALFA to XACML policy language
-
framec
Frame language transpiler — state machines that generate production code
-
sqry-lang-haskell
Haskell language plugin for sqry
-
brainfoamkit
An interpreter for the brainf*** language
-
ilo
token-minimal programming language AI agents write
-
bhc-codegen
Code generation backend for BHC (LLVM backend)
-
spl
Stack Pogramming Language: A simple, concise scripting language
-
lustc
A Lean4 subset to Rust source-to-source compiler
-
xpile
Polyglot transpile workbench: Python/C/Shell/WASM in, Rust/Ruchy/Lean/WASM/PTX/WGSL/SPIR-V/Shell/forjar out, with provable contracts at every layer
-
rowl
Parser for the Dolfin Ontology Language
-
diffsl
A compiler for a domain-specific language for ordinary differential equations (ODE)
-
parlex-gen
Lexer generator ALEX and parser generator ASLR
-
bend-lang
A high-level, massively parallel programming language
-
matchcov
Language-agnostic usefulness and exhaustiveness analysis for pattern matching
-
tpt-telos
Command-line interface for the tpt-telos compiler
-
bicycle_random_numerics
Collect numerics for random Pauli-generated rotations run on the bicycle architecture
-
tinymist-assets
assets for tinymist
-
windy-lang
Windy — a 2D esoteric programming language where code flows like wind
-
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
-
relon-cap
Leaf crate holding Relon's canonical capability data types (CapabilityBit / NativeFnGate / Capabilities)
-
plotnik-compiler
Compiler for Plotnik query language (parser, analyzer, bytecode emitter)
-
infr
A gradually typed superset of R
-
yulang
Experimental language with Simple-Sub-style inference, algebraic effects, effect rows, roles, and Ruby/Perl/Raku-inspired syntax
-
steel-parser
Parser for use within steel
-
baracuda-forge
Build-time CUDA kernel compiler for the baracuda ecosystem: nvcc-driven incremental builds, parallel compilation, GPU auto-detection, and CUTLASS / custom git dependency support
-
gluon_parser
The parser for the gluon programming language
-
draxl-ast
Typed AST and metadata model for Draxl
-
laburnum
An LSP framework for building language servers and compilers, powered by an incremental query tree with content-addressed storage, task-based dataflow, and parallel queries
-
rspack_plugin_rslib
Rslib native plugin
-
lolrust
A transpiler from .meow (lolcat Rust) to valid Rust. i can haz rust?
-
leo-parser-rowan
Rowan-based lossless parser for Leo
-
sema-eval
Trampoline-based evaluator and module system for the Sema programming language
-
elisprs
Emacs Lisp as a fusevm frontend: a reader and compiler to fusevm::Chunk on an ElispHost object heap, with no bespoke VM or JIT
-
bock-air
Annotated Intermediate Representation (AIR) for the Bock compiler — typed, scope-resolved, effect-aware
-
cljrs-compiler
JIT (Cranelift) and AOT compiler backend for clojurust
-
harn-builtin-meta
Shared type definitions for Harn builtin signatures (BuiltinSignature, Param, Ty). Consumed by both harn-parser and harn-vm so signatures stay cycle-free.
-
bvm-lang
Bytecode VM and interpreter loop
-
oxc_transformer
A collection of JavaScript tools written in Rust
-
mist-lang
The Mist programming language compiler
-
flowlog-parser
Parser and typechecker for the FlowLog Datalog language
-
janetrs
High level binding for Janet programming language
-
verse-rs
compiler and bytecode VM for a Verse-aligned language subset
-
analyssa
Target-agnostic SSA IR, analyses, and optimization pipeline
-
pyimports
Parse and analyze the imports within a python package
-
m68000
A Motorola 68000 interpreter, disassembler and assembler (code emitter)
-
vplsfpoael
the best programming language (joke)
-
cargo-abi-audit-cli
Cargo-native Rust/native ABI auditing CLI, scoped honestly to a C-ABI-first workflow
-
lmntalc
A compiler for the LMNtal language
-
lamina-weld
weld - Cross-platform linker. Fast, minimal, drop-in for ld/lld/mold. Links ELF (Linux), PE (Windows), Mach-O (macOS).
-
grabapl
graph-based programming languages, with pluggable type systems and a focus on visible intermediate states
-
slac
The "Simple Logic & Arithmetic Compiler" transforms a single expression into an abstract syntax tree
-
decy-parser
C AST parsing using clang-sys for Decy transpiler
-
preinterpret
An intuitive toolkit to simplify code generation development
-
marigold
Programming Language
-
dlwrap
dlopen wrapper code generator
-
endbasic
programming language - CLI
-
axonyx-core
Core parser, lowering, query model, and SQL draft compiler for Axonyx
-
module-lang
Module and import resolution for multi-file languages
-
metrowrap
A mwcc wrapper
-
t-parser_c
C-syntax parser for the T programming language
-
tishlang_opt
AST optimization pass for Tish (constant folding, short-circuit, etc.)
-
obeli-sk-boa-parser
ECMAScript parser for the Boa JavaScript engine
-
obeli-sk-boa-string
Boa is a Javascript lexer, parser and compiler written in Rust. Currently, it has support for some of the language.
-
galvan
A higher-level programming language that transpiles to Rust
-
phew
Fast HTML + PHP formatter for Yii 2 view files
-
spade-ast
Helper crate for https://spade-lang.org/
-
chalk-recursive
Recursive solver for the Chalk project
-
stoffel-rust-sdk
Rust SDK for building Stoffel MPC applications
-
loom_ruleset
Deterministic data-driven ruleset AST interpreter for the Loom Engine (the Any-System core)
-
lex-syntax
Tokenizer + parser for the Lex programming language
-
ai-sentinel
Compilation wrapper used to fix misc compilations bugs
-
miden-package-registry
Package registry interfaces and dependency resolution for Miden packages
-
loom-language
Loom — an AI-native functional language that compiles to Rust, TypeScript, WebAssembly, OpenAPI 3.0, and JSON Schema with built-in correctness guarantees
-
cargo_pup_lint_impl
Core lint implementations and rustc integration for cargo-pup architectural linting
-
kn-runtime
Dynamic wrapper around CPU and GPU inference
-
rustpython-ast
AST definitions for RustPython
-
sorrel-compute
Generic CPU kernels for Sorrel spike-sorting analysis
-
pielang-cli
Pie language interpreter CLI
-
php-printer
Pretty printer for PHP AST — converts parsed AST back to PHP source code
-
mutica
programming language
-
noise-core
Core of the Noise probabilistic language: lexer, parser, evaluator, sampler
-
nashc
Compiler for the nash programming language
-
pascal
A modern Pascal compiler with build/intepreter/package manager built with Rust
-
lumen-compiler
The AI-Native Programming Language
-
mech-set
Set library for the Mech language
-
elworthy
JIT compiler that specialises Bismut-Elworthy-Li formulas into SIMD kernels for unbiased Monte Carlo Greeks on non-stationary SDEs
-
teeny-triton
Teenygrad is a high-performance, memory-safe Rust ML training and inference library. It targets devices from microcontrollers to traditional GPUs with statically-typed kernels and full async support.
-
ocaml-gen
generating OCaml code
-
leo-abi
ABI generation for Leo programs
-
tsz-parser
TypeScript parser and AST types for the tsz compiler
-
luaur
Luau (Roblox's typed Lua) implemented in Rust: compiler, VM, and type checker. Umbrella crate.
-
zamin
programming language interpreter
-
proto-blue-codegen
AT Protocol code generator: Lexicon JSON -> Rust source
-
cfi-types
CFI types for cross-language LLVM CFI support
-
hilang
A small programming language
-
xbasic64
A BASIC-to-x86_64 native code compiler targeting 1980s-era BASIC dialects
-
harper-comments
The language checker for developers
-
draxl
Agent-native source annotation for semantic program control
-
regorust
Rust bindings for the rego-cpp Rego compiler and interpreter
-
x86_64-assembler
Modern assembler for x64 and x86 instruction sets - strongly typed, object-oriented, zero-dependency core
-
abrase
language
-
elenchus-compiler
Compiles parsed elenchus DSL into a canonical Impossible/CNF clause IR: import resolution, desugaring, atom interning, content-addressed dedup
-
egglang
The Egg Programming Language From Eloquent JavaScript, but in Rust
-
garden-lang
A live programming language
-
garnish_lang
Single library for re-exporting and documenting all Garnish core libraries
-
reg4th
A register allocation library for compiler backends
-
gen-nix
gen — typed Nix AST + pretty-printer + per-crate (crate2nix shape) derivation renderer. Implements theory/NIX-AST.md: every Nix construct the substrate emits is a typed
NixValue… -
rsconstruct
Rust based fast build system
-
lisp-rs
Lisp interpreter in Rust
-
duck-diagnostic
Generic diagnostic engine for building rich error reporting into any tool
-
zapcode-core
A minimal, secure TypeScript subset interpreter — parse, compile, execute, snapshot
-
logicaffeine-language
Natural language to first-order logic pipeline
-
zia
Interpreter Library for the Zia Programming Language
-
single-variable-algebra-compiler
A compiler for the minimalistic programming language single-variable-algebra
-
cyclang
toy language built in LLVM
-
valua-ast
Lua 5.5 AST node definitions shared across the valua pipeline (Lua 5.4 is a supported subset)
-
paxc
A compiler for the pax DSL, producing Power Automate cloud flow definitions
-
lisette-syntax
Little language inspired by Rust that compiles to Go
-
tripley-rpc-idlc
Compiler and plugin host for Tripley RPC IDL
-
scopegraphs
A well-documented port of scopegraphs to Rust
-
funct
A small, functional, embeddable scripting language with a fully reified bytecode VM you can pause, snapshot, and resume
-
xdl-parser
XDL/IDL language parser
-
grepdef
Quick search for symbol definitions in various programming languages
-
vize_atelier_core
Atelier Core - The core workshop for Vize Vue template parsing, transform lanes, and code generation
-
antimony-lang
The Antimony programming language
-
bund
Interpreter and CLI for a Virtual Machine for BUND programming language
-
sema-core
Core types and environment for the Sema programming language
-
junolsp
Language Server for JunoLang
-
tyre-tyr
Tyr CLI
-
rajac-base
Shared foundational utilities for the rajac compiler workspace
-
lutra-codegen
Code generation for Lutra
-
brink-format
Binary interface between brink compiler and runtime
-
cargo_info_types
Parse the output of
cargo infointo well-typed Rust structures -
gollum-ast
Abstract-Syntax-Tree for the Gollum language
-
polonius-engine
Core definition for the Rust borrow checker
-
midenup
The Miden toolchain manager
-
cranelift-codegen
Low-level code generator library
-
mallubind
Native C-ABI bindings for writing libraries for the Malluscript programming language
-
procss
CSS parsing and transformation framework
-
oak-dhall
Dhall language parser with support for functional programming and type system features
-
rlx-umap
Parametric UMAP on RLX — full fit/transform API and k-NN building blocks
-
rust_lisp
A Rust-embeddable Lisp, with support for interop with native Rust functions
-
rustpython-vm
RustPython virtual machine
-
pepl-types
Shared types for the PEPL compiler: AST nodes, Span, errors
-
casm
Crush Assembly (CASM) — bytecode format for the Crush VM
-
mercurio-kerml
KerML and SysML v2 language services, compiler, and simulation for Mercurio
-
aplang
A programming language made to aid students who are taking AP Computer Science Principals
-
ternlang-mcp
MCP server for ternlang — connects any AI agent to balanced ternary decision logic via trit_decide and friends
-
termaid-mermaid
Mermaid parsing for the Rust termaid terminal renderer
-
wasm-pvm-cli
CLI for WASM to PVM recompiler
-
assura-lsp
LSP server for the Assura contract language
-
cream-js
A lightweight compiler for modern web applications
-
cranelift-object
Emit Cranelift output to native object files with
object -
haloumi-ir-gen
IR generation step of the haloumi lowering pipeline
-
forge-lang
Forge — Internet-native programming language with natural syntax, bytecode VM, and built-in HTTP/database/crypto
-
grapheme-compiler
Compiler pipeline for Grapheme source to MIR artifacts
-
surreal-lang
A Rust-inspired language for the BEAM
-
atc-router
Versatile DSL based rule matching engine used by the Kong API Gateway
-
temporaries
Make temporary values useable in a fairly normal style through macros. This nicely wraps the hacks that work around temporaries’ earlier limitations.
-
cargo-util-terminal
Cargo's terminal rendering
-
vibe-ast
Multi-language AST parser with language detection
-
equilibrium-ffi
Automatic C FFI generation for C-compiling languages (V, Zig, C++, C#, Rust, D, Nim, Odin) (unstable and in development)
-
fasb
faceted answer set browser
-
muga
A quiet programming language
-
microcad-lang-parse
µcad language syntax lexer and parser
-
kz80_c
A self-hosting C compiler for Z80 targeting RetroShield hardware
-
ferro-jtype
Type inference for Java class bytecode without JDK symbols
-
amethyst_geode
Turing Machine Programming Language Interpreter
-
bynk-emit
Bynk's build orchestration and TypeScript emission: project discovery, the dependency graph, validation, and the emitter that lowers checked Bynk to TypeScript
-
sixtyfive
An interpreter for the Sixtyfive programming language, designed for teaching computer science to moths
-
typescript
compiler and runtime
-
patch-rexx
A modern REXX interpreter in Rust
-
somni-parser
Grammar parser of the Somni language and VM
-
ebnftobnf
A straightforward EBNF to BNF reducer
-
monkey-parser
a parser for monkey lang
-
cargo-cgp-error-processing
Compiler-free string transforms that make CGP diagnostics readable, driven by the cargo-cgp driver
-
swamp-semantic
semantic types for swamp
-
stak-device
Devices for Stak Scheme
-
corvo7
A toy programming language compiler written in Rust
-
ringkernel-cuda-codegen
CUDA code generation from Rust DSL for RingKernel stencil kernels
-
rl-vm
Bytecode virtual machine for the rl-lang programming language
-
awa5_rs
An AWA5.0 CLI tool written in Rust (btw)
-
qvcm
Register-based bytecode VM with quantum computing functionality
-
typr
A typed superset of R - transpiler and type checker
-
mago-type-syntax
core utilities useful for building lexers and parsers within Mago
-
egglog-concurrency
egglog is a language that combines the benefits of equality saturation and datalog. It can be used for analysis, optimization, and synthesis of programs. It is the successor to the popular rust library egg.
-
naga-rust-back
Backend for the Naga shader translator which generates Rust code
-
mystsh
Mystical shell parser, formatter, and interpreter with Bash support
-
jist
Welcome to Jist a lightweight and efficient programming language built in Rust, designed for simplicity, flexibility, and fast performance with a clean and readable syntax. Github: https://github.com/jon429r/JistR
-
bhc-span
Source location tracking and span management for BHC
-
idpp
ID++ - Bahasa pemrograman berbahasa Indonesia
-
forgellm-frontend
Model parsing (GGUF, SafeTensors) and IR construction for ForgeLLM
-
lc3as
Assembler for the LC-3 that translates assembly source into big-endian object files
-
leap-lang
Leap language parser
-
smelt-stdlib
Shared standard-library shims and diagnostic categories used across the Smelt transpiler
-
splik
programming language identifier kit
-
liturgical-calendar
Liturgical calendar engine for the Catholic Novus Ordo — runtime facade
-
dlexer
A high-performance, functional parser combinator library for Rust
-
bhc-ast
Abstract syntax tree definitions for BHC
-
lite_ml
Lightweight markup language compiler
-
intent-cli
CLI toolchain for IntentLang: check, render, compile, verify, audit, query, lock, fmt, generate, init
-
libwild
that provides a fast Linux linker
-
qir-qis
QIR to Quantinuum QIS (Quantum Instruction Set) compiler
-
ilm
A fun programming language with Islamic terminology
-
argus-lib
Trait debugger analysis for IDE interactions
-
misty-parser
Parser code required by the Misty Compiler
-
bashrs
Rust-to-Shell transpiler for deterministic bootstrap scripts
-
grove-compiler
Season-based compiler pipeline with ternary bytecode — Spring→Summer→Autumn→Winter
-
aardvark-core
Runtime for executing sandboxed python bundles inside V8
-
codonsplice-core
CodonSplice engine — SpliceQL bytecode compiler, VM, and (Phase 4) cnvlens-core bridge
-
zust-compiler
Compiler front-end and semantic lowering for the Zust scripting language
-
chapter3_lexical
A lexical analyzer that returns the tokens you wrote!
-
tspc
TypeSpec compiler CLI — convert .tsp files to JSON, YAML, OpenAPI and more
-
vyre-lower
Substrate-neutral lowering: vyre Program → KernelDescriptor consumed by vyre-emit-* crates
-
hiko-syntax
part of the hiko ML-family scripting language
-
espr
EXPRESS Language compiler
-
netidx-bscript
An incremental scripting language for netidx
-
wright
programming language compiler and tooling
-
tl-ir
Intermediate Representation for ThinkingLanguage table pipe optimization
-
hypothalamus
An optimizing Brainfuck AOT compiler with an LLVM IR backend
-
lykn
A modern Lisp for ECMAScript, the browser, and the Deno JavaScript runtime
-
mmi-cli
CLI and compiler for Mastermind, the BF compiler
-
asg-lang
ASG - A programming language built on Abstract Syntax Graph
-
typst-layout
Typst's layout engine
-
kind2
A pure functional functional language that uses the HVM
-
jjik
LR(1) parser generator
-
llvm-pm
Safe Rust wrapper for LLVM new PassManager
-
cortex-lang
interpreted language for interfacing with Rust code
-
moonjuice-transpiler-luau
Transpile MoonJuice AST nodes to the Luau scripting language
-
llvm-ir
LLVM IR in natural Rust data structures
-
cargo-typify
cargo command to generate Rust code from a JSON Schema
-
fift-cli
A CLI for the Fift esoteric language interpreter
-
ast-demangle
Parses mangled names and produces structured results
-
tremor-script
Tremor Script Interpreter
-
runmat-vm
RunMat virtual machine and bytecode interpreter
-
hugr
Quantinuum's Hierarchical Unified Graph Representation
-
koto
expressive, embeddable programming language
-
unseemly
A typed macro language
-
graphcal-fmt
Type-safe, unit-aware, Git-friendly reactive programming language for engineering calculations
-
luna-jit-llvm
LLVM 18 + inkwell 0.9 alternative JIT backend for the goliajp/luna Lua runtime. Lives alongside
luna-jit(Cranelift); backend selection at runtime via theLUNA_JIT_BACKEND=llvmenv var… -
stator_jse_ffi
Stator JavaScript engine — stable C FFI layer for embedding
-
quickjspp
QuickJS Javascript engine wrapper using quickjs fork named quickjspp
-
tishlang_builtins
Shared builtin implementations for Tish (array, string, object, math)
-
resw
writing RESSA AST parts to a file
-
virtual-rust
A virtual machine that interprets and runs Rust source code directly without compilation
-
uxn-tal
uxntal:// protocol | a Rust library for assembling TAL (Tal Assembly Language) files into UXN ROM files
-
vyre-emit-ptx
PTX text emitter for vyre KernelDescriptor. Produces NVRTC-compatible CUDA assembly.
-
wesl-cli
CLI for the WESL compiler
-
ascent-interpreter
Interpreter and JIT for Ascent Datalog programs
-
umjunsik
Language compiler targeting Lamina IR
-
haskelujah-naming
Name resolution, interfaces, and symbol environments for the Haskelujah compiler
-
cargo-slicer
Speed up Rust release builds by skipping codegen for unreachable functions and processing of other skippable items
-
lift-ast
LIFT compiler framework AST: lexer, parser, and AST for the .lif source language
-
hmacro
macro preprocessor
-
rsjsonnet-lang
A Jsonnet evaluation library
-
miden-format
Formatter for the Miden Assembly language
-
csw-cli
Command-line interface for the Categorical Semantics Workbench
-
tinymist
An integrated language service for Typst
-
kaio
Rust-native GPU kernel authoring framework. Write GPU compute kernels in Rust, automatically lower to PTX. Cross-platform (Windows + Linux), type-safe, no CUDA C++ required.
-
llvm-in-rust-codegen
Machine-independent code generation infrastructure for LLVM-in-Rust
-
zhc_utils
ZHC: Shared utilities
-
horkos
Cloud infrastructure language where insecure code won't compile
-
jrsonnet-evaluator
jsonnet interpreter
-
light_ranged_integers
Ranged integers for stable Rust compiler, zero-dependencies and no unsafe code
-
bliplib
The Bizarre Language for Intermodulation Programming (BLIP)
-
nessa-language
An extensible programming language with a strong type system
-
jzero
A compiler and bytecode VM for the Jzero language (a subset of Java)
-
squid
A RISC-V emulator with AOT compilation for fuzzing
-
turbofuro_worker
Worker executable for Turbofuro
-
zust-vm-spirv
SPIR-V code generation backend for the Zust scripting language
-
typescript-ir
Intermediate representation for TypeScript compiler
-
turing-lib
Turing library for Rust
-
motto
Compiler-as-a-Service: Turn Rust schema.rs into multi-platform SDK toolkits
-
ts-native
TypeScript to native executable compiler - Stable Release
-
gluon_base
Basic type definitions and functions for the gluon programming language
-
edlc_lsp
EDLc Language Sever Protocol implementation
-
penne
pasta-oriented programming language that favors the goto-statement for flow control
-
erg_common
A common components library of Erg
-
runmat-static-analysis
Domain-specific static analysis passes for RunMat
-
mec
mruby/edge compiler cli endpoint
-
aver-lsp
LSP server for the Aver programming language
-
vexil-lang
Compiler library for the Vexil schema definition language — lexer, parser, IR, and type checker
-
ad-astra
Embeddable scripting language platform Ad Astra. Main Crate.
-
uor-prism
Prism standard library (wiki ADR-031): a façade re-exporting uor-foundation's substrate plus the Layer-3 sub-crates (prism-crypto, prism-numerics, prism-tensor, prism-fhe) that contribute…
-
erebus
A CLI message generation library
-
rl-resolver
Name and import resolution for the rl-lang programming language
-
jit-lang
Lower IR to machine code in executable memory and run it now
-
forked_react_compiler
Rust port of the React Compiler, vendored from react/react
-
type-sitter-cli
CLI for type-sitter (generate typed wrappers for tree-sitter grammars from node-types.json and queries)
-
spade-lang
The Spade compiler
-
analisar
A Lua parser for Rust
-
mininip
A minimalist ini file parser (MinIniP stands for Minimalist Ini Parser). It is written in Rust but I will export its API to the C programming language in order to make various bindings
-
bynk-check
Bynk's semantic-analysis layer: name resolution, type checking, the kernel-method and builtin registries, first-party sources, actors, and the captured index/hints tables — the layer between bynk-syntax and the emitter
-
cellang
Interpreter for the CEL expression language
-
jinko
safe, small and fast programming language with Rust interoperability
-
grammatica
representing and transforming formal grammars (Chomsky hierarchy today; extensible toward attribute, probabilistic, and specialized grammars)
-
depinfo
parser for Rust
-
tapir-bf
Tapir is a moderately useful Brainfuck interpreter
-
god-graph
A graph-based LLM white-box optimization toolbox: topology validation, Lie group orthogonalization, tensor ring compression
-
lumic
Lumi compiler
-
chord-progression-parser
a converter from chord progression strings to AST
-
logicaffeine-lsp
Language Server Protocol implementation for LOGOS (the logicaffeine language)
-
cmtc
compiler providing cmtir-based passes to generate backends including FIRRTL, SystemVerilog and simulators
-
rustpython-codegen
Compiler for python code into bytecode for the rustpython VM
-
constraint-compiler
Deterministic projection-to-inference graph compiler for the recursive inference kernel
-
libquil-sys
High-level bindings to libquil
-
alef-backend-magnus
Ruby (Magnus) backend for alef
-
tel
Turbofuro Expression Language
-
flowistry
Modular information flow analysis
-
swipl
A high-level library for building SWI-Prolog extensions and embedding SWI-Prolog in rust applications
-
glua_parser
Parser for Garry's Mod Lua, Lua 5.x, and LuaJIT source files
-
cgrammar
A comprehensive C language grammar parser library written in Rust, implementing the C23 standard (ISO/IEC 9899:2023)
-
cambridge-asm
Run pseudoassembly from Cambridge International syllabus 9618
-
maat_trace
Trace-generating virtual machine for the Maat programming language
-
fugue-sleighc
Wrapper around Ghidra's SLEIGH specification compiler
-
c2rust-ast-builder
Rust AST builder support crate for the C2Rust project
-
dolang
Embeddable public API for the Do language
-
gen-pdc
gen — the Per-Dependency Content-Addressed Cacheability (PDC) contract. The typed variant CATALOG of ecosystem adapters (cargo/gomod/npm/pip/…) + the universal PDC invariant checker…
-
viper-py
A fast Python interpreter written in Rust
-
wscript-cli
CLI runner for Wscript
-
lex
aids in parsing programming languages
-
sqry-lang-php
PHP language plugin for sqry
-
stacky
Programming Language
-
rvsdg
Type-safe standalone implementation of the RVSDG IR with automatic Phi transformation
-
monkey-wasm
monkey lang parser wasm version
-
cljrs-jit
In-process JIT compiler (Cranelift) for clojurust — Phase 10.1
-
pycc-rs
Pin1Yin1 compiler rust implementation
-
tpt-augur-mlir
Probabilistic MLIR-compatible dialect, optimization passes, and TPTIR lowering for Augur
-
strykelang
A highly parallel Perl 5 interpreter written in Rust
-
liteml
一个用 Rust 实现的轻量级标记语言编译器。
-
badder_lang
A specialized programming language built for programming puzzle game Robo Instructus
-
provekit_noirc_evaluator
Evaluator for Noir programs
-
type-sitter-gen
generate typed wrappers for tree-sitter grammars from node-types.json and queries
-
littrs-ruff-python-parser
Vendored ruff_python_parser for littrs (from github.com/astral-sh/ruff)
-
ling-codegen
Code generation backends for Ling (bytecode, WASM, native)
-
stailwc
An experimental transpiler to bring tailwind macros to SWC rocket
-
alef-snippets
Reusable documentation snippet discovery and validation for Alef
-
vize_atelier_sfc
Atelier SFC - The Single File Component workshop for Vize
-
backyard-nodes
Nodes representing PHP code AST
-
plotnik-bytecode
Bytecode format and runtime types for Plotnik
-
boa-cat
Tree-walking ECMAScript interpreter built on ecma-syntax-cat. v0.7.2 lands three integration tests pinning down the existing
new SomeNativeFn(args)dispatch path:expression::construct… -
reqlang-expr
A tiny (bytecode compiled, stack VM interpreted) expression language for reqlang's templating engine
-
lex-ast
Canonical AST + content-addressed identity for Lex programs
-
shader-slang
Rust bindings for the Slang shader language compiler
-
mblf
The MBLF-To-BF compiler written in Rust with Pest. MBLF is a programming language on top of the esoteric programming language Brainfuck
-
qalam
Interpreter for the Qalam programming language. Qalam is a dead-simple, Urdu inspired, interpreted programming langauge.
-
rust-code-analysis-code-split
Fork of mozilla/rust-code-analysis bumped to tree-sitter 0.26 for use by code-split. Computes complexity metrics (cyclomatic, cognitive, Halstead, MI, LOC).
-
ghci
Manage and communicate with ghci (Haskell's GHC interpreter)
-
xee-xpath-ast
XPath parser and AST implementation
-
voce-schema
Voce IR schema definitions and generated FlatBuffers bindings
-
resrap-rs
A rule based code generator
-
provekit_noirc_arena
Arena allocation utilities for the Noir compiler
-
py5
A minimalist Python interpreter written in Rust
-
rat-in-a-tube
Rat In a Tube, Halo: Combat Evolved HSC Script Compiler
-
rust_mir2_wrapper
RUSTC_WORKSPACE_WRAPPER binary for rust_mir2 MIR extraction
-
gleamgen
Gleam generator
-
lu
embedding Luau
-
mux-lang
The Mux Programming Language Compiler
-
onion-vm
Virtual machine runtime for the Onion programming language with async execution and garbage collection
-
apollo-ariadne
A fancy diagnostics & reporting crate
-
kn-cuda-sys
A wrapper around the CUDA APIs
-
parlex
Core support library for parsers and lexers generated by parlex-gen
-
zccache-compiler
Compiler detection and argument parsing for zccache
-
morok-codegen
Backend code generation for the Morok ML compiler
-
mist-codegen
The Mist programming language Rust code generator
-
jimtcl
Embed Jim Tcl in Rust
-
tjs2dec
A krkr2 and krkrz tjs2 bytecode decompiler written in Rust
-
fuellite
Fuel and byte-budget primitives: mechanical termination and output bounds. One shared budget across all composition, so fractal recursion terminates by construction.
-
syntax-core
Fast, multi-strategy parsing and transformation kit for Rust
-
axon-frontend
AXON compiler frontend - lexer, parser, AST, epistemic type system, type checker, IR generator. Zero runtime dependencies. v1.59.0 (Fase 119) adds the two judgments the runtime shares…
-
parsey
parser-generator framework
-
moore
A compiler for hardware description languages
-
kn-graph
A neural network inference graph intermediate representation, with surrounding utilities
-
rune-modules
Native modules for Rune, an embeddable dynamic programming language for Rust
-
hclua
-
crisp
A small, expressive Lisp-inspired programming language
-
falsec
An interpreter and compiler for the esotheric programming language FALSE
-
typst-cli
The command line interface for Typst
-
sema-vm
Bytecode compiler and virtual machine for the Sema programming language
-
gen-bundler
gen — Ruby/Bundler adapter. Parses Gemfile + Gemfile.lock into gen_types::Manifest. The bundler half of the universal package-manager engine; sibling of gen-cargo + gen-npm. Authored…
-
lux-lang
The Lux programming language
-
moa_bitops
位操作原语与动态大小位图
-
wasc
A C-like language compiler for WebAssembly with first-class support for references and tables
-
b2c2-compiler
b2c2におけるBASICコードをCASL2に変換する部分?
-
ellie_engine
Why ellie? Ellie is a type-safe programing language that runs on embedded and sandboxed environments
-
maid-lang
Maid Programming Language
-
morok-runtime
Kernel execution runtime for the Morok ML compiler
-
santiago
A lexing and parsing toolkit for Rust
-
vast
Verilog AST library
-
brvm
Brainrot language compiler and virtual machine
-
darklua
Transform Lua scripts
-
flux-importer
Flux bytecode → synthetic MIR bridge for the cuda-oxide compilation pipeline. Translates agent-native Flux bytecode into MIR compatible with the Rust-to-PTX compiler.
-
st8
Stator JavaScript shell — interactive JS REPL and script runner (like V8's d8)
-
bock-ast
Abstract syntax tree definitions for the Bock language
-
valua-polyfills
Embedded Lua polyfill strings for Lua 5.5 → 5.1 transpilation
-
qala-cli
Command-line interface for the Qala programming language
-
moore-svlog-syntax
The SystemVerilog parser implementation of the moore compiler framework
-
rgsm
An assembler for the Gheith ISA written in Rust
-
cirq-ir
Canonical Cirq IR — the resolved, validated semantic representation
-
go-parser
The parser of the Goscript project
-
pseudo_interpreter
A Pseudocode interpreter
-
sap-parser
The parser crate for the SAP programming language
-
lambda-expr
evaluating string expressions in hot loops
-
sandkiste
Language independent scripting language sandbox API
-
brik64-bir
BRIK-64 BIR bytecode runtime — embed the BIR interpreter in any Rust project
-
masl_bytecode
Maduka Authorization Specification Language (MASL) toolchain and runtime
-
metaltile-codegen
Metal Shading Language (MSL) code generator for MetalTile kernels
-
archscript
programming language — Python-like syntax, Haskell-inspired features, Arch Linux integration
-
rosetta-stone-core
Core types and traits for the Rosetta transpiler
-
windjammer
language inspired by Go, Ruby, and Elixir that transpiles to Rust - 80% of Rust's power with 20% of the complexity
-
nuidl
The nucom IDL compiler
-
polka-rustc
Compiles Polka bytecode to no-std Rust
-
synth-frontend
WASM/WAT parser and module decoder frontend for the Synth compiler
-
leo-std
Embedded Leo standard library source
-
rlibc-extended
A minimal implementation of assumed symbols of libc
-
mosaic-lang
A compiler for Mosaic
-
coe-rs
Type coercion
-
rajac-ballpit
Experimental sandbox binary for rajac development
-
tos-tbpf
Virtual machine and JIT compiler for eBPF programs
-
hacspec
compiler
-
aikup
Manage multiple versions of aiken
-
ringkernel-ir
Intermediate Representation for RingKernel GPU code generation
-
ironmind
A Brainf*ck interpreter and code execution visualizer built in Rust
-
runmat-snapshot
High-performance snapshot creator for preloading RunMat standard library
-
swamp-parser
Parses Swamp programming language source code into an Abstract Syntax Tree (AST) defined in the
swamp-astcrate, using the pest parsing library -
sora-config-format
powerful configuration table compiler for games and data-heavy tools
-
orco
A compiler backend interface
-
c64-assembler
Commodore 64 assembler, outputs directly to .PRG or Dasm source code
-
patch-prolog-compiler
Standalone Prolog compiler (plgc) — compiles .pl to native binaries via LLVM
-
yagbas
programming language that builds programs for the Game Boy
-
oak-typescript
TypeScript frontend for Oak
-
mago-codex
PHP type system representation, comparison logic, and codebase metadata for static analysis
-
bcts
Incremental compiler infrastructure using Salsa
-
rl-lexer
Lexer and tokenizer for the rl-lang programming language
-
astmap-languages
Language parsers and resolvers for astmap (tree-sitter based)
-
lovely
A delightful low-level systems programming language
-
w16-lib
Библиотека для использования W16
-
lilac
Static site generator-esque tool for adding include statements to HTML
-
provekit_noir_artifact_cli
Commands working on noir build artifacts
-
swc_cli
Commandline for SWC
-
ralix
type-safe, tree walking interpreter
-
dark-vm
A new VM called the DarkVM, which focuses on speed and simplicity
-
piccolo
Stackless Lua VM implemented in pure Rust
-
vpratt
absolute zenith of pratt parsing
-
aleph-syntax-tree
Aleph Syntax Tree structure
-
mag_lang
The Mag Language Runtime
-
icss-lang
Indented CSS parser and compiler
-
arithma
An easy to use, domain-specific programming language for numeric mathematics
-
flux-isa
FLUX Instruction Set Architecture — stack-based constraint compilation VM with bytecode encoding
-
harn-glob
Glob pattern matching primitives for the Harn programming language
-
run-kit
Universal multi-language runner and smart REPL
-
blockly-rust-compiler
Rust compiler integration library for visual programming with Blockly - validate and check generated code
-
aegis-lang
A dynamic, interpreted programming language with a high-performance bytecode VM
-
oxc_ast
A collection of JavaScript tools written in Rust
-
pushr
based interpreter for Push programs
-
spyglys
programming language for text manipulation
-
deoptimizer
machine code de-optimizer. By transforming/mutating the machine code instructions to their functional equivalents it makes possible to bypass pattern-based detection mechanisms used by security products.
-
lumen-cli
The AI-Native Programming Language
-
vbscript
lexer and parser
-
rusty-javac
A Java compiler written in Rust
-
torq_lang
A programming language for concurrent dataflow
-
aegean
A fancy diagnostics & reporting crate
-
y-lang
Compiler & Interpreter for the (rather new and very experimental) Y programming language
-
hyeong
Hyeo-ung Programming Language Compiler
-
rubyrs
A tiny Ruby-subset interpreter in Rust, built on top of Prism
-
ospl
the (UNFINISHED!!!) OSPL programming language
-
ty-parser
C-syntax parser for the Ty programming language
-
omg_runtime
The OMG language runtime and virtual machine, providing bytecode execution, REPL, and built-in functions
-
xlang_abi
ABI safe interfaces used by xlang
-
dust-lang
General purpose programming language
-
obeli-sk-boa-engine
Boa is a Javascript lexer, parser and compiler written in Rust. Currently, it has support for some of the language.
-
haloumi-ir
Intermediate representation of the haloumi framework
-
cas-compiler
Bytecode compiler for CalcScript programs
-
tpt-eidos-erasure
Proof-term erasure for tpt-eidos: strip refinement witnesses from a kernel-checked module, producing a computational-core IR
-
mogi_sleigh_parser
Parser for Sleigh specifications
-
oak-lua
High-performance incremental Lua parser for the oak ecosystem with flexible configuration, supporting lightweight scripting and embedded development
-
paramodel
— parameter-modelling, trial enumeration, plan compilation, and plan execution. This crate re-exports every paramodel sub-crate as a module (
paramodel::elements,paramodel::plan… -
sleigh-compiler
Rust bindings for the Ghidra SLEIGH compiler. Used to compile processor .slaspec files into .sla files
-
regulus
interpreted language with very simple syntax and zero dependencies
-
leo-retriever
A retriever for the Leo programming language
-
smpl
Core library to compile the SMPL language
-
zust-vm-metal
Metal shader source generation backend for the Zust scripting language
-
calyx
Compiler Infrastructure for Hardware Accelerator Generation
-
rew-compiler
CoffeeScript/TypeScript compiler for the Rew runtime
-
extendable_vm
that simplifies implementation of stack VMs
-
typst-svg
SVG exporter for Typst
-
error_ctx
Minimal context error crate with Temporary/Permanent status and compiler-enforced context on public APIs
-
steel-gen
Code generation crates for use within steel
-
logics-rs
Logics is a user-friendly formula language with a subset of Python's expression syntax
-
compiletest_rs
The compiletest utility from the Rust compiler as a standalone testing harness
-
rustc_codegen_spirv-types
SPIR-V backend types shared between rustc_codegen_spirv and spirv-builder
-
sleuth
Extremely opinionated testing framework generating an exact specification and reducing code to its minimal implementation
-
claw10-icvs
ICVS compiler wrapper for Claw10 OS
-
wkwrap
webKNOSSOS wrapper is a file format designed for large-scale, three-dimensional voxel datasets. It was optimized for high-speed access to data subvolumes, and supports multi-channel data and dataset compression.
-
mathcompile
High-performance symbolic mathematics with final tagless design, egglog optimization, and Rust hot-loading compilation
-
circomspect-program-structure
Support crate for the Circomspect static analyzer
-
voile
dependently-typed row-polymorphic programming language
-
diatom-std-core
Diatom core standard library
-
typiskt
Type systems as a library
-
swamp-vm-disasm
disassembler for the opcodes in the swamp vm
-
dynamik
A fast, powerful, expressive and typesafe language
-
slothlang
A weird, slow and a bit moldy interpreted programming language
-
celsium
building interpreters
-
ag-c
The ag language compiler - a Rust-inspired functional language
-
lift-cli
LIFT compiler CLI: verify, analyse, optimise, print, compile, simulate, and predict from the command line
-
walter-redditlang
Build tool for https://github.com/elijah629/redditlang
-
nash-ast
Canonical AST for the nash programming language
-
oxide_lisp
lisp interpreter engine in Rust
-
yamlate
A cross-language interpreter library that dynamically evaluates YAML attributes given variable bindings
-
sphinx-lang
An intepreter for a dynamic language implemented in Rust
-
koopa
generating/parsing/optimizing Koopa IR
-
cambridge-asm-cli
Run pseudoassembly from Cambridge International syllabus 9618
-
worldinterface-flowspec
FlowSpec parser, validator, and compiler to ActionQueue DAG
-
galvan-ast
AST for the Galvan programming language
-
tishlang_vm
Bytecode VM for Tish
-
rusty-basic
Tiny BASIC interpreter written in Rust
-
diplomat-tool
generating FFI bindings for various languages
-
pr47
A semi-experimental programming language. Still working in progress.
-
kdl-script
execute kdl documents!
-
brief-core
Compiler library for the Brief markup language: lexer, parser, AST, HTML/LLM emitters, formatter, and Markdown-to-Brief converter
-
sylt-parser
Parser for the Sylt programming language
-
sema-reader
Lexer and s-expression parser for the Sema programming language
-
bop-lang
A small, embeddable, dynamically-typed programming language with zero dependencies
-
slasherc
A programming language for school, built in Rust
-
parsuna
recoverable, pull-based parsers with precise errors
-
chimpanzee
Monkey programming language implementation (interpreter, compiler and formatter), with added features
-
lisette-semantics
Little language inspired by Rust that compiles to Go
-
sk-lang
The SK Programming Language interpreter
-
nmp-feed-session
Shared feed-session compiler for NMP runtimes
-
send-future
Ergonomic and performant fix for https://github.com/rust-lang/rust/issues/96865
-
stak-process-context
Process context for Stak Scheme
-
prql-compiler
PRQL is a modern language for transforming data — a simple, powerful, pipelined SQL replacement
-
sapp-kms
Part of miniquad rendering library. Orignally this was a sokol-app C code transpiled to rust with c2rust and partially rewritten to more idiomatic rust.
-
pliron-llvm
LLVM dialect for pliron
-
bappy-script
Gankra's toy compiler
-
patch-prolog-shared
Shared term representation and atom interning for patch-prolog2
-
silkworm_err
Compiler diagnostics for silkworm
-
edlc_core
Core library for the EDL compiler
-
marzipan
A macro processor for ZZT worlds
-
naga-rust-embed
Translates WGSL shader code to Rust embedded in your Rust code
-
scoutlang
A web crawling programming language
-
lex-bytecode
Bytecode compiler + VM for Lex
-
language-reporting
Diagnostic reporting for programming languages
-
bff
A complete Befunge 98 interpreter in Rust
-
llvm-infra
LLVM Compiler Infrastructure in Rust
-
bpf-ins
working with eBPF instructions
-
hiko-types
part of the hiko ML-family scripting language
-
lamina-platform
Platform and target detection for Lamina compiler
-
simple-symbol
Convenient, basic String interning
-
aver-rt
Shared Rust runtime pieces for Aver-generated programs
-
xasm-rs
generating linux 32/64 bit assembly easily
-
fervid_css
Transformer for Vue
<style>blocks -
minicode
Esoteric programming language
-
morok-dtype
Type system for the Morok ML compiler
-
ternlang-core
Compiler and VM for Ternlang — balanced ternary language with affirm/tend/reject trit semantics, @sparseskip codegen, and BET bytecode execution
-
moto
motivated automation
-
leuchtkraft
A logical programming language
-
rspression
A high-performance, lightweight expression calculation engine
-
sixu
Experimental Visual Novel Scripting Language
-
bytevm
A tiny bytecode virtual machine
-
moore-vhdl-syntax
The VHDL parser implementation of the moore compiler framework
-
eureka-optimizer
A short description
-
alan-von-palladium
The Alan von Palladium Programming Language - A systems programming language combining Turing's correctness with von Neumann's performance
-
vosh
General-purpose programming language
-
koto_bytecode
The bytecode compiler used by the Koto programming language
-
luaur-vm
The Luau register virtual machine and standard library (Rust)
-
graphcal-package
Type-safe, unit-aware, Git-friendly reactive programming language for engineering calculations
-
lancelot-bin
binary analysis tools for x32/x64 PE files
-
ale_python_parser
Python Parser : generate Aleph Syntax Tree
-
leo-abi-types
ABI type definitions for Leo programs
-
irvm
A IR compiler target with a Rust friendly API that lowers to LLVM IR
-
beadie
Hot-function promotion broker for interpreter-to-JIT tiering
-
forgellm-codegen-metal
Metal GPU code generation for Apple Silicon inference in ForgeLLM
-
jzero-codegen
TAC and bytecode code generation for the Jzero compiler
-
controlmap-parser
(De)Serializer of
controlmap.txtin Skyrim -
assura-mcp
MCP (Model Context Protocol) server for Assura AI agent integration
-
sddrs
Bottom-up Sentential Decision Diagram compiler library
-
bicycle_numerics
Compute numerics for bicycle circuits
-
gccjit_sys
Raw bindings to libgccjit. Companion to the gccjit crate.
-
phoron_asm
A Jasmin-compatible Assembler for the JVM
-
sui-bytecode
Bytecode compiler and VM for the sui Rust-native Nix evaluator
-
saxaboom
Binding library for Metal Shader Converter
-
xee-interpreter
Interpreter for XPath and XSLT
-
syntax-parser-generator
Independent library for generating lexical-analyzers and LALR parsers
-
egglog-ast
egglog is a language that combines the benefits of equality saturation and datalog. It can be used for analysis, optimization, and synthesis of programs. It is the successor to the popular rust library egg.
-
oak-html
HTML markup language parser with support for web content and document structure processing
-
librasm
using RASM
-
typst-batch
Typst helper library for batch processing — friendly API, shared resources, virtual files, customizable diagnostics
-
scaly
programming language
-
vize_atelier_dom
Atelier DOM - The DOM compiler workshop for Vize
-
nilang
A scripting language interpreter for Advent of Code
-
moa_rand
xoshiro256++ 伪随机数生成器
-
lift-core
LIFT compiler framework core: unified SSA intermediate representation (IR) for AI and quantum — types, values, operations, blocks, regions, verifier
-
michaelb/sniprun
A neovim plugin to run lines/blocs of code (independently of the rest of the file), supporting multiples languages
-
gramma
Generate a scannerless parser by declaring types
-
lift-import
LIFT compiler importers: PyTorch FX, ONNX, Qiskit, and OpenQASM 3 frontends
-
airl-typecheck
Bidirectional type checker for AIRL IR with effect tracking
-
paramodel-plan
Paramodel test-plan layer: TestPlan, Axis, ExecutionPolicies, OptimizationStrategy, TrialOrdering, plan-level bindings
-
ilex
quick and easy lexers for C-like languages
-
rail-lang
A straightforward programming language. Rail is currently experimental and subject to drastic breaking changes.
-
fnotation
lower-house syntax for programming language experimentation
-
xliff2
XLIFF 2.0 read/write library
-
nightjar-lang
A declarative, prefix-notation DSL for formal verification of structured data
-
rex-ast
Rex: A strongly-typed, pure, implicitly parallel functional programming language
-
kz80_lua
A Tiny Lua interpreter and compiler for RetroShield Z80
-
tl-stream
Streaming and pipeline engine for ThinkingLanguage (Phase 4)
-
libdusk
implements most of the compiler for the Dusk programming language, in library form
-
rythonc
Command-line Python-to-Rust compiler for the Rython toolchain
-
libket
Runtime library for the Ket programming language
-
provekit_noirc_driver
Noir compiler driver
-
rusm-jsc
Build-time QuickJS bytecode compiler for RUSM TS bundles (version-locked to the js-runner's rquickjs)
-
lift-opt
LIFT compiler pass manager: 13 optimisation passes — constant folding, DCE, CSE, tensor fusion, gate cancellation, qubit routing
-
ergotree-ir
ErgoTree IR, serialization
-
zub
A fast, stack-based virtual machine for dynamic languages, with an intuitive IR-builder, garbage collection and NaN-tagging
-
yggdrasil-shared
Yggdrasil Compiler core shared components
-
pitusya
Programming Language
-
static-reflect
Static type information, giving a form of compile-time reflection
-
seq-runtime
Runtime library for the Seq programming language
-
glslang-sys
Raw C bindings to glslang
-
hydroper_jet_compiler
Hydroper Jet Language Compiler
-
maat_bytecode
Bytecode format and serialization for the Maat virtual machine (MVM)
-
type-lang
Type representation, unification, and inference scaffolding
-
zul
General-purpose programming language
-
haskelujah-parser
Lexer, layout, and parser pipeline for the Haskelujah compiler
-
hugr-llvm
A general and extensible crate for lowering HUGRs into LLVM IR
-
annotate-snippets
Format diagnostic reports, including highlighting snippets of text
-
sqry-lang-c
C language plugin for sqry
-
pddl_rs
PDDL parser
-
repl_lib
creating REPL interpreters
-
rlx-mlx-sys
Low-level MLX C++ build + C ABI shim for RLX (vendored mlx, NVRTC-free)
-
brainterpreter
An interpreter for a Bauble toy programming language
-
gluon_c-api
C-api for gluon, a static, type inferred programming language for application embedding
-
fr
A programming language with an unusual compiler backend
-
aspl
Programming Language
-
sym-bridge
Sym client for Rust - use any language's libraries from Rust
-
husk-parser
Parser for the Husk programming language
-
tpt-eidos-parser
Lexer, AST, and recursive-descent parser for the tpt-eidos language
-
bfrunner
A Brainfuck interpreter in Rust, for shits and giggles. Not for production.
-
kombucha
A minimal and malleable programming language for symbiotic end-user programming
-
flt
a 'lite' functional language
-
ternary-compiler-optimizer
Optimization passes for ternary bytecode
-
mini-brainfuck
A super small brainfuck interpreter and compiler
-
rtk-rustc-driver
The rustc driver (don't use this directly) for Rust Type Kit - query Rust types and produce FFI types
-
lutra-interpreter
Bytecode interpreter for Lutra programs
-
llvmkit-ir
LLVM IR data model in pure Rust: types, values, modules, instructions, builder
-
cow-parser
A parser for the esoteric Cow programming language
-
karaka-core
Karaka language core: lexer, parser, evaluator
-
tyre-ty
Ty compiler CLI
-
sigil-parser
Parser and native compiler for the Sigil programming language
-
b2c2-parser
b2c2におけるBASICコードのパーサー?
-
rns-lang
RNS language parser, compiler, and assembler library for the Lagertha VM project
-
ferropascal
A Pascal-to-Rust transpiler that converts Borland Pascal source code into idiomatic Rust
-
kronk
interpreter - a silly, experimental language with surprisingly loud output
-
theforce
A Star Wars inspired programming language
-
scrapile
A somewhat fully-fleged rust-like programming language that, surprisingly, compiles to scratch
-
controlled-option
Custom Option type with explicit control over niches and memory layout
-
tishlang_ui
Shared JSX lowering and UI runtime (vnode, hooks, host protocol) for Tish
-
rosetta-stone-smalltalk
Smalltalk language frontend for Rosetta transpiler
-
virdant
modern hardware description language
-
nash-cli
The Nash programming language
-
mochi-lang
concatenative programming language
-
seer
symbolic execution engine for rust
-
zerodds-dlrl-codegen
DLRL code-gen helpers: emits home/object boilerplate for cpp/csharp/java/ts
-
aiscript-arena
safe, incrementally garbage collected arenas
-
nl_opt
Verilog compiler driver for running safety-net passes
-
alef-codegen
Shared codegen utilities for the alef polyglot binding generator
-
atlas_vm
The Atlas77 Virtual Machine
-
mist-parser
The Mist programming language parser
-
verter_span
Typed span primitives for Verter — compile-time safety for position encoding
-
p2sh
Programming language interpreter
-
swiftsc-cli
Command-line interface for SwiftSC-Lang compiler
-
ashpaper
Rust Inpterpreter for Esopo language AshPaper conceived by William Hicks
-
clac-lang
Reference implementation of Clac++, a simple stack-based postfix (reverse polish notation) calculator/programming language
-
hugr-passes
Compiler passes for Quantinuum's HUGR
-
fennec
Programming Language
-
agent-wire-compiler
Canonical Wire action compiler primitives for the agent-wire.com substrate
-
flow_ast
Abstract Syntax Tree definitions for the Flow programming language
-
dragon_blade
A transpiler from Rust to Overwatch Workshop
-
mutica-semantic
Semantic analysis library for the Mutica programming language
-
py-ast
Pin1Yin1 ast definition and parse for pycc-rs
-
cbe_rbpf
Virtual machine and JIT compiler for eBPF programs
-
strop
stochastically generates machine code
-
clutils
A common library for building interpreter and compiler
-
php-wasm
WebAssembly bindings for the PHP parser and printer
-
stainless_script
Visual node-based programming language
-
verter_core
Vue 3 SFC compiler - transforms Vue Single File Components to render functions with TypeScript support
-
valua-parser
Recursive-descent Lua 5.5 parser for the valua transpiler
-
garden-lang-parser
A live programming language
-
fta
Fast TypeScript Analyzer
-
luna-jit
Lua runtime in pure Rust — full 5.1/5.2/5.3/5.4/5.5 support. Equivalent to
luna-coreplus a Cranelift-backed JIT (method + trace) and the lua.h-compatible C ABI. (Thelunacrate name on crates… -
ken
Compiler, tooling, and language server for the Ken programming language
-
codegen-lang
Backend abstraction targeting LLVM, Cranelift, or bytecode
-
hornbeam
template engine (high-level crate for use in applications)
-
s-expression
parser
-
ty-ree
AST definitions for the Ty programming language
-
Cecile
Cecile Programming Language that is designed to be simple, fast
-
aleph2py
Transpiler Aleph to python
-
turbofuro_runtime
Runtime for Turbofuro visual programming language
-
panproto-jit
LLVM JIT compilation of panproto expressions for accelerated data migration
-
catalyst_entities
Low level data-structures for multithreaded and incremental compilation
-
ilvm
An interpreter for an assembly-like language
-
devsper-compiler
Distributed AI Swarm Runtime
-
depyler-annotations
Annotation parsing and processing for Depyler
-
pfcl-repl
PFCL REPL and file runner — pure functional language with content-addressed catalog
-
oters_lang
Language definitions and interpreter for the oters programming language
-
tupa-lint
Linter for TupaLang source code
-
rustc-demangle-capi
C API for the
rustc-demanglecrate -
fidget-jit
Native JIT compiler for Fidget
-
reporting
diagnostic reporting for compilers
-
kansei
programming language
-
ryna-language
An extensible programming language with a strong type system
-
boron-lang
efficient, compiled programming language
-
typed-sf
Typed ready-to-use implementation of SmallF*ck language in Rust
-
symboscript-formatter
SymboScript formatter
-
binpattern
binary code pattern extractor for yaras
-
runmat-turbine
Cranelift-based JIT compiler for RunMat - the optimizing tier of our V8-inspired execution model
-
luaur-compiler
Luau source-to-bytecode compiler (Rust)
-
dashc
Compiler, lowering, and artifact generation for DashScene
-
NULL
Interpreter for the NULL language
-
lamina-ras
ras - as/GAS alternative. Cross-platform assembler: assembly source (.s) to relocatable object files (.o). Used by Lamina, usable standalone.
-
hyperparse
A HyperText Markup Language (HTML) parser written in Rust. (WIP)
-
tyre-t
T compiler CLI
-
rigz_runtime
Handles parsing and converting rigz to its VM instructions (for syntax highlighting use tree-sitter-rigz instead)
-
luar_lang
A small, class-based scripting language inspired by Lua and Luau, with a tree-walking interpreter, static checker (Ferrite), garbage collector, precompilation format, and host embedding API
-
codemem-index
Tree-sitter code indexing for Codemem memory engine
-
llk
A fast, little an easy to understand LL(k) (LL(1) for now) library and compiler compiler (soon)
-
gitrevset
A domain-specific-language to select commits in a git repo. Similar to Mercurial's revset.
-
draxl-agent
Internal agent-edit backend and MCP server for Draxl
-
compiler-builtins-snapshot
Snapshot of the compiler-builtins crate
-
sap-shared
The shared crate for the SAP programming language
-
typst-html
Typst's HTML exporter
-
somni
scripting language and VM
-
gust-lang
The Gust programming language compiler — parse .gu state machine files and emit Rust, Go, WASM, no_std, or C FFI code
-
mdl_monkey
Monkey programming language from https://interpreterbook.com/
-
lovm2
a lightweight virtual machine with a focus on simplicity and extendability
-
dlang
Programing language from scratch
-
bitsyc
Bitsy compiler written in Rust
-
palate_polyglot_tokenizer
A generic programming language tokenizer
-
uwcl_rbpf
Virtual machine and JIT compiler for eBPF programs
-
jit-codegen
Code generator for arm64jit instruction metadata
-
dolang-bytecode
Bytecode format and verification for the Do language
-
libbfi
Extendable brainfuck interpreter library
-
axonml-jit
JIT compilation for Axonml tensor operations
-
abacus
The mathemagical programming language
-
lia
A high-level language for Rust
-
nadesiko3
Japanese programming language Nadesiko v3
-
telltale-machine
Protocol machine for choreographic session type protocols
-
rustc-ap-rustc_target
Automatically published version of the package
rustc_targetin the rust-lang/rust repository from commit 9a27044f42ace9eb652781b53f598e25d4e7e918 The publishing script for this crate lives at: https://github… -
definitely
Codepaths that are statically unreachable according to the compiler's intraprocedural control flow analysis
-
wmlua
-
yggdrasil-parser
Yggdrasil parser by yggdrasil
-
c-emit
Polished builder API to write C Code
-
libjuno
JunoLang
-
onlang
A programming language running on json or yaml
-
lua2hcb_compiler
A compiler for Lua-like scripts to HCB
-
recc
A C compiler with graphs
-
mech-compare
Comparison library for the Mech language
-
linguist-rs
that can be used to detect programming languages
-
whitespacers
A whitespace JIT-compiler, for when your whitespace just isn't executing fast enough
-
the-code-graph-parser
Multi-language source code parser for The Code Graph
-
rasm-lang
RASM is a small Interpreted Programming Language
-
typeslice
type-level slices
-
dunh
Highlights code for printing
-
kind-pass
A lot of compiler passes for the kind compiler
-
spade-diagnostics
Helper crate for https://spade-lang.org/
-
mini-c-parser
minimal C language lexer & parser & virtual executer from scratch
-
c2rust-refactor
C2Rust refactoring tool implementation
-
cluna
convert Lua code into Clue code Made by MarkosTh09
-
reproto
compiler
-
tattle
Error reporting for compilers
-
midenc-frontend-wasm-metadata
Shared frontend metadata codec for the Miden Wasm frontend
-
patchouly
A copy-and-patch JIT framework in Rust
-
rohanasantml
An easy way to write your messy html code in a better way
-
bcomp
A compiler for a subset of the BASIC language
-
sieve-rs
Sieve filter interpreter for Rust
-
kz80_microperl
A minimal Perl interpreter and compiler for RetroShield Z80
-
wesl-c
C bindings for the WESL compiler
-
moa_unsafe_list
Linux 风格侵入式双向链表
-
ruby-sys
Low level bindings to MRI, Matz's Ruby Interpreter
-
lua-parse
omniLua’s Lua parser — internal crate; depend on
omnilua -
hiko-compile
part of the hiko ML-family scripting language
-
svod-codegen
Backend code generation for the Svod ML compiler
-
synox
Program synthesis of string transformations from input-output examples
-
snli
An interpreter for the Syntax Null Language Esolang
-
oxc_allocator
A collection of JavaScript tools written in Rust
-
phenotyper
Core compiler library for the Phenotyper structural artifact definition language
-
a4
A forth-inspired, bytecode-compiled scripting language for Anachro Powerbus
-
lamina-codegen
Codegen utilities for Lamina (register allocation, ABI, frame management)
-
nextjs_react_compiler_lowering
Rust port of the React Compiler, vendored from facebook/react
-
oak-scheme
Scheme functional programming language parser with support for Lisp dialect and symbolic computation
-
jack_compiler
Jack compiler for the nand2tetris course
-
phpdoc-parser
Structural PHPDoc parser. Parses doc-comment blocks into a tag/prose AST with accurate spans; tag bodies exposed as raw text.
-
rubyrs-cext
CRuby-shape C ABI for hosting C extensions inside rubyrs (spike: Level 0)
-
bhc-session
Compiler session state, options, and configuration for BHC
-
relon-rs-shims
Runtime ABI shims for Relon AOT-compiled functions linked into Rust binaries
-
msiz_rustc-ap-rustc_target
Automatically published version of the package
rustc_targetin the rust-lang/rust repository from commit 74d5c70b174f06843049af2d764ff57ddc81c81c The publishing script for this crate lives at: https://github… -
dependency_lister
Tools to list dependencies from .d files generated by clang or GCC
-
hornvale
experimental, idiosyncratic text adventure game written in Rust
-
intarsia
An extensible Rust optimization framework
-
dolang-compile
Parser, resolver, and bytecode compiler for the Do language
-
rustycpp
An attempt to implement the C++20 standard. This is mostly to have fun & learn rust
-
swamp-code-gen-program
converts a Swamp program to swamp-vm opcodes
-
claw-common
The Claw language common types and functions
-
flux-ast
Universal Constraint AST — single source of truth for constraint semantics across all representations
-
tl-ast
Abstract Syntax Tree definitions for ThinkingLanguage
-
pop65
A 6502 assembler
-
fxrazen
compiler
-
voce-validator
Voce IR reference validator and CLI toolchain
-
bitis
Bitwise serialization of messages defined in a data description language with interfaces for rust, python and c++
-
oak-csharp
C# frontend for Oak
-
swamp-script-node
compiler node with documentation and meta information
-
koi-gc
koi programming language garbage collector
-
haloumi-synthesis
Synthesis step of the haloumi lowering pipeline
-
webfluent
The Web-First Language — compiles to HTML, CSS, JavaScript, and PDF. 50+ built-in components, reactivity, routing, i18n, SSG, and template engine.
-
shulkerbox
creating Minecraft datapacks in Rust
-
god-gragh
A graph-based LLM white-box optimization toolbox: topology validation, Lie group orthogonalization, tensor ring compression
-
lumi-core
Core lumi library
-
mist-analyzer
The Mist programming language Analyzer LSP
-
valua-lint
Static analysis lints for the valua transpiler. Public crate; stable from 1.0.
-
aivm
Artificial intelligence that embraces the hardware it runs on
-
smelt-frontend-ts
TypeScript frontend for the Smelt transpiler: lowers strict TypeScript to Smelt HIR via oxc
-
malbolge
Programming Language in Rust
-
guryvsr
esoteric programming language gur yvsr
-
draxl-cli
Command-line interface for Draxl
-
trashcan
language which compiles to Visual Basic 6 / VBA
-
koto_parser
The parser used by the Koto programming language
-
monkey-object
a object system for monkey lang
-
paranoia
Programmatically determine whether code was optimized away or not
-
edlc_analysis
Code analysis utils EDL compiler
-
rpiet
An interpreter for Piet, the esoteric programming language
-
mlua-crc16
A Rust-native implementation of LuaRocks youlu/luacrc16 for mlua
-
lykn-cli
Lykn language CLI — scaffolding, building, testing, and publishing for Lykn projects
-
walnut
Walnut File Systwm Experimental file system with inode level encryption
-
rosetta-stone-ir
Rosetta Intermediate Representation for cross-language transpilation
-
ryft-core
Core abstractions of the Ryft library
-
cargo-whynot
Cargo subcommand to discover why a function is unsafe
-
ugo
uGo Compiler
-
shavenscript
Lightweight programming language made in rust with support for array and basic operations
-
slj
Programski jezik v slovenščini | A programming language in Slovenian
-
scurry
A component-based object-oriented language
-
intcode_compiler
AoC 2019 Intcode compiler, interpreter and transpiler
-
oxerun
Compiler bits to create Rust unikernels for Xen
-
MotoGarage_parser
A parser and interpreter for MotoGarage DSL, a language for managing motorcycle collections
-
modu
A fast and simple turning-complete interpreted language
-
verbena
Scripting language
-
lexit
A Lexical Analysis tool for defining a language and lexing it into tokens
-
husk-dts-parser
TypeScript declaration file (.d.ts) parser for Husk
-
swift-precompiler
A precompiler for Swift that allows you to use additional macros, include files, and more
-
tsar
Tsar programming language
-
fortraith
Compile-time compiler that compiles Forth to compile-time trait expressions
-
nexus-lib
The raw implementation of the nexus scripting language
-
just-engine
A ground-up ES6 JavaScript engine with tree-walking interpreter, bytecode VMs, and Cranelift JIT compiler
-
leftpad-str
Obviously the best crate for the Rust programming language. The crate serves the only goal of implementing
leftpadfunction. -
shut_up
Use trust_me、shut_up or other keywords replace 'unsafe'. Compiler shut up! Readers shut up too! My code has no bugs, trust me!
-
langpipe
A flexible Rust library for building custom compilers and interpreters with a modular pipeline for lexing, parsing, transforming, optimizing, and generating code
-
qcs-sdk-python
Python bindings to qcs-sdk-rust
-
prune-lang
Prune is a constraint logic programming language with branching heuristic
-
bock-source
Source file management and FileId mapping for the Bock language compiler
-
stak-engine
Stak Scheme scripting engine for Rust
-
oakc
A portable programming language with a compact backend
-
rscheck-semantic
Semantic backend surface for rscheck
-
nlcc
Nameless C Compiler
-
paijorot
interpreted programming language implemented in Rust. It's designed as a hobby project with unique 'brainrot' syntax. ***(FULLY AI WRITTEN)***
-
jkl-lang
Open Source Programming Language
-
psilva_functions
Bibliotetca de funções do Psilva
-
fastc-lsp
Language Server Protocol implementation for FastC
-
spaik
Programming Language
-
air-types
Types for the TNJ Assembly Intermediate Representation (AIR)
-
orion_lib
parsing and executing the Orion Programming Language
-
langkit
A builder library for creating programming languages in Rust
-
argmin_testfunctions
Test functions for optimization algorithms
-
vermilion-vm
A virtual machine written in Rust
-
graviton
fast programming language that is minimal and simplistic with a simple and easy to read compiler. Everything is an expression unless a semicolon is used
;then it becomes a statement… -
ty_python_core
internal component crate of Ruff
-
cbqn-sys
FFI bindings to CBQN
-
nvvm
High level bindings to libnvvm
-
rustc-hex-viewer
compiler as a hex viewer
-
artlr_syntax
syntax analysis
-
ape_ast
abstract syntax tree for Aperture programming language
-
trustme
Tell the compiler that you can be trusted to write unsafe code!
-
monkey-lexer
a lexer for monkey lang
-
parsanol
High-performance PEG parser library with packrat memoization and arena allocation
-
lithia
Embeddable and simple lisp dialect
-
bril-frontend
AST and type-checking for Bril programs
-
rust--
Turn Rust into C++
-
blitz_lang
A Hobby Programming Lang with Rust
-
hzlang_parser
A parser for the "hz" programming language
-
songe
Interpreter for a Scheme-like language for graphics and games
-
qvnt-qasm
A OPENQASM 2.0 Parser
-
roto
a statically-typed, compiled, embedded scripting language
-
logicaffeine-base
Tier-0 foundation for logicaffeine: arena, interner, spans, the exact numeric/quantity/money/time/UUID value-type tower, and the shared MD5/SHA-1 hash oracle
-
lang-interpreter
reimplementation of the Standard Lang interpreter
-
ferrum_compiler
Compiler library for the Ferrum programming language
-
lex-store
Content-addressed on-disk store for Lex stages, branches, and traces
-
mago-collector
gathering and managing issues from various Mago tools, including support for suppression pragmas
-
wrecc
A x86_64 C99 compiler written from scratch
-
celestial-hub-compass
ETAC compiler
-
fusabi-frontend
Frontend (parser, compiler) for Fusabi language
-
lua-cli
The lua-rs command-line interpreter: Lua 5.4 in safe Rust
-
duskphantom-backend
Backend for DuskPhantom Compiler
-
ablescript
The best programming language
-
xlang_host
Interface for determining and using platform-specific properties of the host system
-
etcetera-compiler
A Rust-based compiler project
-
type-bridge-core-lib
TypeQL AST, schema parser, query compiler, and validation engine for type-bridge
-
dragon_rd_parser
A Recursive Descent Parser Based Loosely On The Dragon Compiler Book. You can type an id operator id expression to see how it would get parsed.
-
bomlamaal
Bømlamål as a programming language
-
masl_diagnostics
Maduka Authorization Specification Language (MASL) toolchain and runtime
-
rascal_scanner
Rascal programming language scanner
-
OOLANG
An esoteric stack-based programming language, where all instructions are different variations of the character 'O'
-
dez80
A Z80 instruction decoding and (dis)assembly library
-
request_compiler
Request Compiler Optimized for Batching Requests
-
dismael
Disassembler for Asmodeus binary files with intelligent analysis
-
tabulon
A high-performance, JIT-compiled expression evaluation engine using Cranelift
-
rshyeong
Hyeong-lang interpreter
-
symjit-bridge
a bridge bwtween Symjit compiler and Symbolica CAS
-
rpg-compiler
A compiler library for the rpg esoteric programming language
-
badeline-plugin
Darkside reflection for Rust
-
rustc-ap-rustc_parse
Automatically published version of the package
rustc_parsein the rust-lang/rust repository from commit 9a27044f42ace9eb652781b53f598e25d4e7e918 The publishing script for this crate lives at: https://github… -
rever
Interpreter and REPL for the Rever language
-
extern-existential
Rust extern existential types prototype
-
enalang
Exhaustingly Notorious Algorithms - umbrella package
-
lep
Mini language for interactive consoles, featuring small code footprint
-
vexil-codegen-rust
Rust code generation backend for the Vexil schema compiler
-
spliceql
query language frontend for CodonSplice — lexer, parser, AST, bytecode compiler
-
rustc_get_version
rust compiler get version utility
-
create-farm
Create Farm cli tool
-
aion-lib-arraymap
A wrapper around Vec<T> with a freelist. Preserves index validity on mutations without heavy generation counters.
-
souper-ir
manipulating Souper IR
-
polyglot_tokenizer
A generic programming language tokenizer
-
apollo-compiler
A compiler for the GraphQL query language
-
clear-cache
A native implementation of
__builtin___clear_cachewithout dependency of GCC/Clang -
forked_react_compiler_hir
Rust port of the React Compiler, vendored from react/react
-
bytebraise-syntax
BitBake parsing, syntax, and AST definitions for bytebraise
-
lib-ruby-parser-ast
AST for lib-ruby-parser
-
vue-oxc-parser
Covert Vue AST (vue-compiler-core) to JSX AST (oxc)
-
brainfuck
interpreter and modules
-
bhc-hir
High-level Intermediate Representation for BHC
-
cuda_builder
Builder for easily building rustc_codegen_nvvm crates
-
haskelujah-backend-llvm
LLVM IR backend for the Haskelujah Haskell compiler
-
iaith
Implementing toy languages in rust
-
spl_frontend
Compiler-Frontend for SPL
-
sussy
pierwszy kwietnia
-
rcc4r
C compiler implemented in Rust with only 4 raw-functions
-
magc
The Mag Language Compiler
-
dylan
Dylan
-
the-super-tiny-rusty-compiler
A super tiny and rusty compiler
-
icelang
high-level programming language created for the purpose of learning about programming language design and implementation
-
ion_shell_parser
Parser for the scripting language of the ion shell
-
rustycli
🦊 Access the rust playground right in terminal
-
scout-parser
A web crawling programming language
-
jit-assembler
A multi-architecture JIT assembler library for runtime code generation
-
sap-cli
The command line interface for the SAP programming language
-
quench
A programming language
-
ncc
Compiler for custom modes on Novation MIDI devices
-
dolfin-diagnostic
Unified diagnostic types for the Dolfin toolchain
-
skrusty
Translating C to Rust
-
fidget-bytecode
Bytecode representation for Fidget expression tapes
-
lexerus
annotated lexer
-
mri-sys
Rust bindings to Mat'z Ruby interpreter
-
welly-parser
An artisanal parser for the Welly programming language
-
typst-syntax
Parser and syntax tree for Typst
-
tale
A Scripting language for TTRPG Tables
-
backyard-parser
Parse PHP code to AST node
-
sqry-lang-python
python language plugin for sqry
-
tenda-reporting
Reporting utilities for the Tenda programming language
-
parlex-calc
Parlex example: simple calculator
-
tyr-backend_ty
Tyr to Ty compiler
-
provekit_noirc_frontend
Frontend of the Noir compiler
-
rust-visitor
Visitor trait for Rust AST based on rust-analyzer
-
treeedb-csharp
Generate Datalog facts from C# source code
-
trans_py_c
Python subset → C transpiler for OS kernel and embedded development
-
ljf
tutorials
-
vk_execute_compiler
VK execute compiler
-
fusabi-pm
Fusabi Package Manager
-
forgellm-codegen-cpu
CPU code generation (x86 AVX2/512, ARM NEON) for ForgeLLM
-
husk-lang
The Husk programming language compiler
-
maat_ast
Abstract syntax tree (AST) for the Maat programming language
-
smc-assembler
assembler for a variety of MineCraft architectures
-
new_project
Basic math operations
-
kodept
compiler with dependent types support in mind
-
dibs-qgen
Query DSL code generator for dibs (parses .styx query files into Rust and SQL)
-
rubble-templates-evaluators
A set of parsers, evaluators and compilers for text templates
-
App1
A sample Rust library project
-
canadensis_dsdl_frontend
Compiler front-end for the Cyphal Data Structure Description Language
-
wirespec
Type-safe protocol description language — compiler, verifier, and LSP
-
sync-ls
Synchronized language service inspired by async-lsp, primarily for tinymist
-
sylt-std
Standard library for the Sylt programming language
-
paxforth
Pax Forth programming language for Pax Consola, a development environment for vintage computers and consoles
-
trogdor
Error handling for programming languages
-
gex_sys_build_parse_mak
Parse mak file to build gex-sys
-
ffmmlc
FFMML command-line compiler
-
bop-vm
Bytecode compiler and stack VM for the Bop programming language
-
mallardscript
Hak5 DuckyScript extended language compiler
-
oxc_codegen
A collection of JavaScript tools written in Rust
-
hiko-cli
part of the hiko ML-family scripting language
-
teolang
A programming language design to be easy to learn for kids
-
uv-types
internal component crate of uv
-
shortlang
A programming language designed for code golfing
-
jitvm
a tiny i64-only language with a bytecode interpreter and a hand-rolled x86-64 jit
-
strontium
A register-based bytecode machine for statically and dynamically typed programming languages
-
ankha
scripting toolset
-
ppppp
Test
-
elina
Safe, high-level Rust wrapper for ELINA
-
fervid_transform
Transformations for the fervid crate
-
erg_compiler
Centimetre: the Erg compiler
-
llvm-wrapper
Safe llvm-sys wrapper
-
huam-rust-utils
这是一个用于学习rust的工具库,记录一些常用的工具函数
-
rscmm
C-interpreter
-
modelx
Compiler for Modelx files
-
seacc
A sea-of-nodes C compiler, written in Rust
-
fusabi
A potent, functional scripting layer for Rust infrastructure
-
rsaeb
A no_std + alloc interpreter for A=B ordered rewrite programs
-
hvm1
A massively parallel functional runtime
-
ptoxide
A virtual machine to execute CUDA PTX without a GPU
-
nodarium_utils
A collection of utilities for Nodarium
-
pen-ffi
FFI library for Pen programming language
-
cargo_experiment_c
experiment with cargo
-
simple-script-compiler
A tiny simple script language compiler/interpreter for learning and testing
-
ric-engine
Rust Interactive Console
-
sonatina-parser
Parser for sonatina-ir text format
-
gs2compiler
Compiles GS2 source code into GS2 bytecode
-
tylisp
A domain-specific language for expressing complex type bounds
-
bork
Pretty print syntax errors for your parser or interpreter
-
pk_compiler
The Palacinke lang bytecode compiler
-
code-gen
aids in code generation
-
my_project0
-- log 0.4.* (test0 0.2.0)
-
htn_planner
HTN parser and planner
-
TypeScript-Rust-Compiler
High-performance TypeScript to Rust compiler
-
rustpython-jit
Experimental JIT(just in time) compiler for python code
-
egglog-numeric-id
egglog is a language that combines the benefits of equality saturation and datalog. It can be used for analysis, optimization, and synthesis of programs. It is the successor to the popular rust library egg.
-
coda-runtime
the runtime for coda, an experimental scripting language
-
zoisite
programming language designed specifically for competitive programming
-
py-declare
type declare system for pycc-rs
-
graphcal-io
Filesystem implementations for the Graphcal compiler
-
mango_interpreter
The Mango programming language interpreter (UNDER CONSTRUCTION)
-
texlang
TeX language interpreter
-
string_cache_plugin
A string interning library for Rust, developed as part of the Servo project − compiler plugin
-
lisette-emit
Little language inspired by Rust that compiles to Go
-
bfi
Print a configurable list of info about a file or directory
-
sourcemap-resolver
Sourcemap resolving library and CLI
-
svod-dtype
Type system for the Svod ML compiler
-
scalyc
Compiler for the Scaly programming language
-
sila-transpiler-infrastructure
transpiler infrastructure for every platform
-
cranelift-interpreter
Interpret Cranelift IR
-
yarcd
It's an mistyping use yaCRd don't use this crates if you can remove it !
-
fomoscript
Toy scripting language
-
sabre-lang
The sabre programming language
-
swamp-compile
Main driver for the Swamp compiler, orchestrating bootstrapping, dependency loading, parsing, and semantic analysis phases
-
brink-compiler
Compiler for inkle's ink narrative scripting language
-
sassers
A Sass compiler in Rust
-
smpli
Interpreter for the SMPL language
-
monkeyinterpreter
An interpreter written in Rust for the monkey programming language described in the book 'Writing An Interpreter In Go' (https://interpreterbook.com/)
-
yagbas_asmtypes
The assembly data type for the yagbas compiler
-
remir
MIR library designed to be used easily and be efficient
-
b2c2-casl2
b2c2におけるCASL2の雑なパーサー?
-
shaqsnake_crate
My first crate
-
intent-codegen
Skeleton code generator for IntentLang specifications (Rust, TypeScript, Python, Go, Java, C#, Swift)
-
git-voyage
Programming guide patching tool
-
moore-vhdl
The VHDL implementation of the moore compiler framework
-
i8051
An emulator for the i8051 (MCS-51) microcontroller
-
itsy
Strongly typed scripting language with a rusty syntax and nice Rust integration
-
stck
An embeddable interpreted language written fully in rust
-
ast_debug
Rust compiler plugin that generates relatively readable AST for inspection
-
bonk
Improved Studying
-
vcompiler_tools
Some useful stuff for making simple compilers
-
flow_analyzer
Semantic analyzer for the Flow programming language
-
art_documentation_demo
Just a demo from The Rust Programming Language book
-
tinymist-world
Typst's World implementation for tinymist
-
molt-forked
Embeddable TCL interpreter for Rust applications (personal forked)
-
zirael
Compiler
-
koi-lang
🐟 High-level programming language 🐟 Cross-platform 🐟 Blazing performance 🐟 Static linking 🐟
-
cala-cel-interpreter
An interpreter for the Common Expression Language (CEL)
-
escriba-vm
Tatara-lisp runtime host for escriba — embeds tatara-lisp-eval's Interpreter<EscribaHost>, exposing editor operations as native Lisp fns that read a snapshot and emit typed, sandboxed effects
-
changepacks-cli
CLI interface and commands for changepacks
-
melody_compiler
The Melody language compiler
-
lisette-format
Little language inspired by Rust that compiles to Go
-
crispr_guessing_game
My first small rust project
-
lora-compiler
Query-plan compiler for LoraDB's Cypher implementation
-
ext-string
An attempt to extend rust String struct with functionality from other programming languages
-
garguile
guile bindings for rust
-
anyscript-compiler
A compiler for the AnyScript programming language, and Self Extracted Archives
-
ternlang-lsp
LSP 3.17 language server for ternlang — hover docs, code completion, and live diagnostics for .tern files
-
genotype_compiler
Genotype language compiler
-
clang-preload
Sample library in rust
-
quantpiler
Сompiler of classical algorithms into oracles for quantum computing
-
regorus
A fast, lightweight Rego (OPA policy language) interpreter
-
fexplib
lower-house syntax for programming language experimentation
-
funki_templates
A framework for creating functional domain specific languages
-
dasn1-notation
A compiler for the ASN.1 notation language
-
ryft-macros
Ryft procedural macros
-
lau-agent-runtime
Self-compiling agent runtime — agents build their own interpreters, compilers, and runtimes
-
jacob
Jacob's Awesome Compiler Of BITS
-
diatom-std-os
The diatom programming language
-
my_parser_some
Some description
-
rustleaf
programming language interpreter written in Rust
-
quickscript
A quick programming language with a compiler implemented in Rust
-
swamp-eval
tree-walking interpreter for executing the Swamp Abstract Semantic Graph (ASG) from
swamp-semantic. Primarily for debugging/testing, not performance. -
cranelift-reader
Cranelift textual IR reader
-
brk_rolldown_ecmascript
ECMAScript AST and parsing utilities for Rolldown
-
airlang_bin
Air is a universal, reliable, and lean programming language
-
c2rust-transpile
C2Rust transpiler implementation
-
qianlv_minigrep
A mini grep project for <<The Rust Programming language>>
-
rigz_ast
AST parser for the rigz programming language
-
rocalang
A contractual language for the AI era
-
specl-syntax
Lexer, parser, and AST for the Specl specification language
-
abstraps
Extensible compiler middle layer with abstract interpretation and code generation to MLIR
-
gccarch
Report architecture information from GCC's backends list
-
progenitor-hk
An OpenAPI client generator
-
gonidium
A DSL compiler and REPL for typed numeric expression pipelines
-
airl-project
Project and workspace management for AIRL: history, queries, projections
-
tishlang_cranelift
Bytecode to native via Cranelift
-
decy-analyzer
Static analysis and type inference for C code
-
enalang_vm
Exhaustingly Notorious Algorithms - virtual machine
-
merge-lang
Merge Programming Language
-
lib_stacked
Virtual Machine Byte Code For Compilers
-
evco
Incomplete Genetic Programming library for Rust
-
oak-objective-c
Objective-C object-oriented programming language parser with support for Apple platform development and runtime features
-
hbc
Random program that does random stuff
-
treeedb-c
Generate Datalog facts from C source code
-
lamina-ir
Lamina Intermediate Representation — high-level SSA IR for the Lamina compiler
-
lci
A LOLCODE interpreter written in Rust
-
duck-diag
Generic diagnostic engine for building rich error reporting into any tool
-
fbp
Flow Based Programming for the Rust language
-
hern
A small language compiled to Lua for LuaJIT
-
sakuramml
MML(Music Macro Language) compiler, MML to MIDI
-
syntax-rs
parsing programming languages
-
ksplang
interpreter
-
gdl-parser
A parser for GDL (game description language)
-
tex_engine
A modular crate for building TeX engines
-
shawn
Yo
-
bhc-linker
Linking support for BHC
-
fmsample_test
something something something dark side
-
diatom
programming language
-
flow_stdlib
Standard library for the Flow programming language
-
goxoy-interpreter
Sistem bilgisini veren kitaplik
-
ruau
Pure Rust implementation of Luau and its analyzer
-
koi-parser
koi programming language parser
-
monkey
Interpreter for the Monkey programming language
-
wavm-cli
A 64 bit register based virtual machine
-
claw-cli
The compiler for the Claw language
-
lucia-lasm
LASM - Lucia Assembly Language
-
xlang_targets
ABI Safe Interfaces for target triples and discovering compiler-required information about targets
-
junior
Programming language transpiling to rust
-
aarchmrs-instructions
AARCHMRS-generated ARM instructions functions
-
t-parser_sln
SLN-syntax parser for the T programming language
-
espy-tail
espy's bytecode compiler
-
generic-bnp
GenericBnP is a Branch & Price library for the programming language Rust. It supports custom cuts, dual stabilization, primal heuristics, and multithreaded evaluation.
-
grandiorite
hello world crate
-
cang
A coin based interpeter
-
tlq-fhirpath
FHIRPath engine
-
obfstr
Compiletime string constant obfuscation for Rust
-
test_zia
Test Library for the Zia Programming Language
-
cartes_rbpf
Virtual machine and JIT compiler for eBPF programs
-
stack-assembly
minimalist, stack-based, assembly-like programming language
-
mist-api
The Mist programming language module system
-
ra-ap-rustc_hir
Automatically published version of the package
rustc_hirin the rust-lang/rust repository from commit 5113ed28ea1451a13eae3a05dca0dbabfd56f587 The publishing script for this crate lives at:… -
vermilion_jit
A toolkit for JIT compilation
-
pepl-compiler
PEPL compiler: orchestrates the full compilation pipeline
-
tan
language
-
bwd
Backwards linked-lists
-
xtuc-sieve-rs
Sieve filter interpreter for Rust
-
impc
A compiler for the IMP programming language
-
harborc
A language that ports: targeting your thermostat, UFO, and kitchen sink
-
jzero-semantic
Semantic analysis and type checking for the Jzero compiler
-
xrcf
eXtensible and Reusable Compiler Framework
-
oak-tcl
Tcl language parser with support for scripting, command substitution, and procedural programming features
-
asum
Some description
-
pydis
Python 2.7 bytecode disassembler
-
toyc
The toylang compiler
-
shellscript
Extremely basic shellscript parser
-
karx_crate
Karx's crate
-
edlc_codegen_cranelift
Cranelift codegen backend for the EDL compiler
-
cargo-prompt
Recursively minify and concatenate source code into a markdown document for llm prompting
-
dig2memory
AST index and dependency graph server for code intelligence
-
rusche
A lightweight Scheme interpreter embeddable in Rust applications
-
golang-type
Golang Type
-
luaur-bytecode
Luau bytecode format and builder (Rust)
-
verilogae_util
Uilites for the rust/python glue generated by VerilogAE
-
maat_errors
Compiler error types and diagnostic infrastructure for the Maat programming language
-
remarklib
The core of the Remark programming language
-
nextjs_react_compiler_reactive_scopes
Rust port of the React Compiler, vendored from facebook/react
-
cpprs
C pre-processor on Rust source files
-
hugr-cli
Compiler passes for Quantinuum's HUGR
-
sql-ast
A lean sql AST and parser
-
papyri-lang
Compiler for the Papyri markup language
-
dimpact
impact analysis from diff
-
parser-c
Macros for parser-c
-
vyre-emit-naga
Naga IR emitter for vyre KernelDescriptor. Produces wgpu-compatible compute shaders.
-
sap-ast
The abstractact syntax tree crate for the SAP programming language
-
rust-scheme
Scheme(R7RS) interpretor/compiler rust implementation
-
gluon_vm
The virtual machine for executing the gluon programming language
-
assura-stdlib
Assura standard library contracts and prelude types
-
uiua_parser
Uiua parser implementation
-
bfy
Brainfu*k interpreter and REPL written in Rust
-
rascal_bytecode
Rascal programming language bytecode
-
graphix-compiler
A dataflow language for UIs and network programming, compiler
-
syntactic_heap
A framework designed for representing Abstract Syntax Trees
-
midenc-frontend-masm
MASM disassembler frontend for the Miden compiler
-
lwb-parser
parser framwork with automatically generated ASTs for the LWB project
-
flow-gate-ffi
C-ABI foreign function interface for flow-gate, enabling Python/R bindings
-
libicsneo
Rust API for libicsneo
-
rispy
A Lisp in Rust
-
zkpyc-stdlib
Standard library for the ZKPyC compiler
-
haloumi-lowering
Core traits for enabling types to integrate with the codegen module
-
lemonlang
an experimental, modern, purely safe, programming language
-
lovm2_error
a lightweight virtual machine with a focus on simplicity and extendability
-
parsentry-core
Core types and traits for Parsentry
-
rustcbuildx
$RUSTC_WRAPPER tool to sandbox cargo builds and execute jobs remotely
-
script-format
DSL to format data via rhai scripting
-
rush-analyzer
A semantic analyzer and type-annotator for the rush programming language
-
logo-web
Web-based IDE for Logo programming language
-
brainfuck-plusplus
A brainfuck interpreter and compiler with some extra functionality
-
kz80_ws
WordStar clone for Z80 - Retro word processor on the RetroShield
-
setjmp
/ longjmp support
-
tr-lang
A programming language made to bring syntax closer to Turkish
-
paramodel-compiler
Paramodel compiler: turns a TestPlan into an ExecutionPlan via the four-stage reducto-derived pipeline. v0.1 scope covers the trivial case; advanced reductions are follow-up slices.
-
demi
An interpreter for the Demi programming language
-
avdl
Avro IDL compiler that turns .avdl into .avpr and .avsc JSON files
-
polonius-the-crab
Tools to feature more lenient Polonius-based borrow-checker patterns in stable Rust
-
rivescript-core
Core data types and traits for RiveScript
-
oneai-workflow
OneAI workflow compiler, DAG, validator, executor, StateGraph, and StateGraphExecutor
-
ffi_reflect_csharp
C# code generator for the
ffi_reflectpackage -
phoenix-lang
fast programming language
-
xasm
Compiler for the xasm programming language
-
destack
Rust client for Destack
-
evcxr_jupyter
A Jupyter Kernel for Rust
-
chomatter_cli
Compiler for the language
-
mech-io
Input/output library for the Mech language
-
rascal_parser
Rascal programming language parser
-
stak-file
File system for Stak Scheme
-
vue-compiler-core
Vue compiler in Rust's core component
-
woojin
Woojinlang interpreter written as Rust
-
relon-object-link
ET_REL -> ET_DYN link pass used by the v5-gamma native AOT pipeline before handing bytes to relon-object-cache
-
aion-lib-num
Number related utilties
-
voce-compiler-webgpu
Voce IR WebGPU compiler — compiles 3D scene IR to WebGPU render pipelines
-
lazyk-rust
Interpreter for Lazy K programming language
-
lift-export
LIFT compiler backends: LLVM IR, ONNX (opset 21), OpenQASM 3 exporters; CUDA PTX and XLA planned
-
klang
programming language
-
fervid_parser
Vue SFC parser for the fervid crate
-
toylang
CLI/Wrapper
-
bynkc
The Bynk compiler — a typed function-then-context DSL that compiles to TypeScript
-
flux-vm-v3
FLUX constraint enforcement bytecode VM — v3 architecture
-
rustc-ap-rustc_attr
Automatically published version of the package
rustc_attrin the rust-lang/rust repository from commit 9a27044f42ace9eb652781b53f598e25d4e7e918 The publishing script for this crate lives at: https://github… -
maat_vm
Stack-based virtual machine for the Maat programming language
-
treeedb-javascript
Generate Datalog facts from JavaScript source code
-
brainoxide
An optimizing Brainfuck compiler/interpreter
-
hydroper_razen
Razen MXML compiler
-
cgp
A language extension for Rust, with pluggable trait implementations at compile-time
-
charon_ariadne
A fancy diagnostics & reporting crate - resigned for crates.io/charon
-
asa
Advanced Subleq Assembler. Assembles 'sublang' to subleq
-
nextjs_react_compiler
Rust port of the React Compiler, vendored from facebook/react
-
kz80_ml
Tiny ML compiler for the Z80 processor with Hindley-Milner type inference
-
rust-compile
Go on. Compile it.
-
typst-utils
Typst
-
rumya-binding
Rumya programming language's binding for Rust
-
tan-lang
namespace for tan-lang.org crates
-
proto-vulcan
A miniKanren-family relational logic programming language embedded in Rust
-
liexpr
parsing and evaluating simple expressions
-
dolang-private-test
Test support utilities for Do language crates
-
fractran_macros
A compiler plugin that converts Fractran code into Rust at compile time, letting your Fractran programs be optimised by LLVM to super-fast native code
-
open-vaf
A compiler frontend for VerilogA aimed predominently at compact modelling
-
wedpr_ffi_macros
WeDPR ffi shared macros
-
rurust
High level Ruby VM bindings
-
logicuniverse
Universal Tri-Axial Fractal Topology (ZYModel) implementation in Rust
-
cfg_compiler
cfg setup
-
ruski
combinator calculus
-
orbitc
The Orbit Compiler Infrastructure
-
vyre-driver
Driver layer: registry, runtime, pipeline, routing, diagnostics. Substrate-agnostic backend machinery. Part of the vyre GPU compiler.
-
sari
arithmetic expression evaluator
-
dwanim-state
Rust-core + Python DSL video renderer
-
apiel
A subset of the APL programming language implemented in Rust. Exports a macro for evaluating APL expressions from Rust code, providing a way to solve some problems in a very concise manner.
-
kz80_smalltalk
Tiny Smalltalk to Z80 compiler for RetroShield hardware
-
luaur-analysis
Luau type checker and type inference (Rust)
-
tt-toolkit
A collection of macros for rapidly prototyping programming languages
-
diatom-core
The diatom programming language
-
vexil-codegen-go
Go code generation backend for the Vexil schema compiler
-
svod-runtime
Kernel execution runtime for the Svod ML compiler
-
ux-compiler
UX Framework Complier
-
bpf-script
A small scripting language and compiler for creating eBPF programs at runtime
-
stormchaser-dsl
A robust, distributed workflow engine for event-driven and human-triggered workflows
-
roost-lang
Interpreter library for the roost language
-
forked_react_compiler_lowering
Rust port of the React Compiler, vendored from react/react
-
ketos
Lisp dialect scripting and extension language
-
crane-win64
A high-performance direct-to-binary compiler backend with built-in IR parser
-
brainstem
A Brainfuck compiler and interpreter library, with a BrainStem frontend language
-
euphony-compiler
compiler infrastructure for euphony compositions
-
tetherscript
A dynamically-typed scripting language with Rust-style ownership, implemented as a bytecode VM in Rust
-
phptaint
Security-focused PHP lexer, parser, AST, and configurable taint analysis engine
-
oysterpack
Platform
-
rascal
A parser and compiler for Flash ActionScript 2 files into SWFs
-
haskelujah-ast
Abstract syntax tree types and helpers for the Haskelujah Haskell compiler
-
lib-zinc
Standard library for Zinc Programming Language
-
llvm-in-rust
Top-level facade crate for the LLVM-in-Rust compiler pipeline
-
kz80_calc
VisiCalc-style spreadsheet for Z80 - Retro computing on the RetroShield
-
petr-profiling
tools for profiling the performance of the petr compiler
-
calyx-ir
Compiler Infrastructure for Hardware Accelerator Generation
-
ringkernel-wgpu-codegen
WGSL code generation from Rust DSL for RingKernel
-
masl_hir
Maduka Authorization Specification Language (MASL) toolchain and runtime
-
skiff
An immutability-first, functional scripting language with a friendly syntax and compiler/interpreter written in Rust!
-
ara_source
A Source library for Ara Programming Language 🗃
-
spade-typeinference
Helper crate for https://spade-lang.org/
-
bitsy-lang
Bitsy is a modern hardware description language
-
beni
Typed Rust wrapper over the mruby C API, sitting on the
beni-sysbindgen surface -
surplus-cli
CLI for the Surplus JSX compiler
-
raic
Raic programming language — compiles to Rust
-
kodept-ast
compiler with dependent types support in mind
-
dalbit
A Luau-to-Lua transpiler
-
hel
HEL — Heuristic Expression Language: a deterministic, auditable expression language & parser, AST, builtin registry and evaluator
-
umpl
meme language that is a mix of c like languages and lisp like languages
-
obscura-core
Core obfuscation engine: AST transforms, options, pipeline. Rust port of javascript-obfuscator.
-
fennec-vfs
Fennec Programming Language
-
ra_ap_rustc-dependencies
TBD
-
lift-sim
LIFT compiler static analysis: shape propagation, FLOP counting, memory analysis, noise simulation
-
mutica-compiler
Compiler library for the Mutica programming language
-
acadcheck
flexible library for building checkers used in programming contests or homeworks
-
lower-ir-utils
Helpers for mapping Rust types to Cranelift JIT signatures, lowering call arguments, and reducing module boilerplate
-
phper-test
PHPer testing utilities
-
bock-errors
Diagnostic error types and source span machinery for the Bock language compiler
-
codegem
A small code generation library
-
kind-derive
Derive generator the kind compiler
-
sancov
Rust bindings to LLVM’s
SanitizerCoverageinterface -
gladiator
A concurrent, modular and small garbage collector
-
ivm-compile
The official compiler framework for ivm
-
transhader
Transpile shaders on the fly using procedural macros
-
leo-disassembler
A disassembler for the Leo programming language
-
wick-core
Core expression language for wick
-
distrustc-client
A Rust-compatible distcc implementation
-
lamina-mir
MIR (Machine Intermediate Representation) type definitions for Lamina
-
quail
Programming Language
-
c64-assembler-6502
Definition of 6502 instruction set
-
miden-package-registry-local
Filesystem-backed local package registry for Miden packages
-
sp1-recursion-compiler
Compiler for SP1 recursion circuits
-
scala
A experimental Scala interpreter written in Rust: lexer, parser, type inference, and tree-walking evaluation with a REPL
-
backyard-generator
Convert AST node back to PHP code
-
shulkerscript
language implementation with compiler
-
rs-luau
Minimal overhead Luau bindings for Rust!
-
lexlite
Byte-cursor lexer kit for purpose-sized languages: comments, idents, digits, and UTF-8-safe char decode by construction
-
mathic
A compiler with builtin support of symbolic operations, built with LLVM/MLIR
-
vexpresso
A minimal Kernel/vau-calculus Lisp with first-class operatives and environment-based IO
-
jaust
Java ecosystem tools in rust a learning project
-
litua
Read a text document, receive its tree in Lua and manipulate it before representing it as string
-
csw-generate
Code generation for the Categorical Semantics Workbench - generate type checkers and interpreters from derived type systems
-
elworthy-expr
Symbolic expression AST, canonicalisation, and CSE for elworthy
-
ptx_compiler
High level bindings to CUDA's ptx compilation APIs
-
luna-aot
Ahead-of-time compiler from Lua source to self-contained native binary, built on luna-core's VM. v1.3 scaffold ships the bytecode-embed pipeline (Lua source → luna bytecode dump →…
-
vyre-self-substrate
Vyre self-substrate: vyre using its own primitives on its own scheduler problems. The recursion-thesis layer between vyre-primitives and vyre-driver.
-
w16-ir
Промежуточное представление w16, и оптимизации
-
tsz-binder
TypeScript name binder for the tsz compiler
-
rigz_vm
Stack based VM for rigz
-
xlsynth-pir-compiler
Rust-native compilation for xlsynth PIR functions
-
scheme4r
Scheme interpreter for rust
-
palacinke
useless scripting lang
-
codelighter
A fast error, warning and notes highlighter for Rust
-
langbox
framework to build compilers and interpreters
-
scout-lexer
A web crawling programming language
-
go-types
The type checker of the Goscript project
-
polka-rs
Bytecode schema for the Myriad runtime (Abrase language)
-
ana-lang
A small interpreted language
-
parol
LL(k) and LALR(1) parser generator for Rust
-
grove-ast
Abstract syntax tree types and balanced ternary primitives for the Grove compiler ecosystem
-
sqry-lang-javascript
JavaScript language plugin for sqry
-
haloumi
Entrypoint crate for the Haloumi framework
-
ttk91
A parser, compiler and emulator library for the TTK91 instruction architecture
-
cedar-policy-validator
Validator for the Cedar Policy language
-
XLang-Rust
An experimental cross-platform dynamic strong-typed programming language written in Rust
-
zinc-lang
Interpreter for the Zinc Programming Language
-
krnlc
Kernel compiler for krnl
-
bop-sys
Standard host integration for the Bop programming language
-
treeedbgen
Parse node-types.json from a tree-sitter grammar
-
valua-diagnostics
Diagnostic types and reporting for the valua transpiler
-
rustplacements
compiler plugin for modifying string literals
-
primate
A small DSL for cross-language constants. Write once, generate typed Rust, TypeScript, and Python.
-
robson_compiler
Dependency of the robson cli
-
meadorc
meador scripting language compiler
-
cjc-diag
Diagnostic infrastructure and error codes for CJC
-
brink-environment
The reified, content-addressed compilation Environment value plus the effectful Project/SourceTree producer (#1306)
-
gibberish-core
Core types and functions for Gibberish parsers
-
monty-pool
A sandboxed, snapshotable Python interpreter written in Rust
-
provekit_noirc_errors
Error reporting types for the Noir compiler
-
lex-vcs
Agent-native version control: typed op log + attestation graph
-
pseudocode_cie_9618
pseudocode interpreter for the cie 9618 spec
-
clover
A scripting language
-
sylt-compiler
Compiler for the Sylt programming language
-
cirq-frontend
Cirq frontend pipeline: source → AST → IR → Netlist
-
graphcal
Type-safe, unit-aware, Git-friendly reactive programming language for engineering calculations
-
wthr-lang
An experimental programming language for weather calculations/applications
-
sus-proc-macro
Proc-macros for use in the sus-compiler
-
guile-sys
Low-level bindings to GNU Guile
-
sprout
growing simple, but beautiful AST trees 🌳
-
noname
Some creates
-
enalang_compiler
Exhaustingly Notorious Algorithms - compiler
-
ape_parser
syntax analysis for Aperture programming language
-
carlo
interpreted programming language
-
evscript
An extensible bytecode-based scripting engine
-
ezno-checker
A fast and correct TypeScript type checker with additional experiments
-
rajac-types
Type system data structures for the rajac compiler
-
laburnum-syntax-macro
Proc-macros for defining CST and AST node types in language frontends built with the laburnum LSP framework
-
gust-lsp
Language Server Protocol (LSP) implementation for the Gust state machine language
-
fastc
A safe C-like language that compiles to C11
-
brainfuckr
brainfuck interpreter written in Rust
-
diplomat_core
Shared utilities between Diplomat macros and code generation
-
jeff-format
Rust bindings for the jeff exchange format
-
rajac-symbols
Symbol tables and semantic symbol data for rajac
-
pycrust
A sandboxed python interpreter (and soon to be compiler)
-
bynk-fmt
Formatter for the Bynk DSL (used by bynkc-lsp)
-
forgellm-codegen-gpu
GPU code generation via wgpu/WGSL for ForgeLLM
-
tl-compiler
Bytecode compiler and VM for ThinkingLanguage (Phase 2)
-
brainfuck-cli
Brainfuck CLI interpreter written in Rust
-
yagbas_asttypes
Abstract Syntax Tree type (and parser) for yagbas
-
source-span
Source code mapping and display utilities
-
rocks-lang
Crafting Interpreters' Lox Language
-
monkey-interpreter
an interpreter for monkeylang
-
tenda-parser
Parser for the Tenda programming language
-
symboscript-parser
SymboScript parser
-
rust-guile
Scheme runtime in your Rust program
-
arbor-core
AST parsing and code analysis for Arbor
-
jzero-vm
Bytecode interpreter and VM for the Jzero language
-
egglog-union-find
egglog is a language that combines the benefits of equality saturation and datalog. It can be used for analysis, optimization, and synthesis of programs. It is the successor to the popular rust library egg.
-
mijit
Experimental JIT compiler generator
-
numbat
A statically typed programming language for scientific computations with first class support for physical dimensions and units
-
oak-python
Hand-written Python frontend
-
artlr_lex
lexical analysis
-
kind-checker
Type checker for the kind compiler
-
tidepool
Compile Haskell effect stacks to Cranelift JIT, drive from Rust
-
callisp
A lisp interpreter that can be used with WASM
-
kaledis_dalbit
A fork of a Luau-to-Lua transpiler based on darklua to use for kaledis
-
flycatcherc
The front-end of the Flycatcher compiler
-
moore-common
The common core of the moore compiler framework
-
moss
Experimental Moss interpreter
-
ampc
Compiler for the Amp language
-
hax-frontend-exporter-options
The options the
hax-frontend-exportercrate is sensible to -
tinymist-lint
A linter for Typst
-
draxl-patch
Structured semantic patch operations over the Draxl model
-
stator_jse
Stator JavaScript engine core — parser, bytecode compiler, Maglev JIT, interpreter, GC
-
guile
Safe bindings to GNU Guile
-
metals
A meta programming language for Composable Systems
-
hiko-vm
part of the hiko ML-family scripting language
-
falsec-compiler
FALSE compiler
-
finx
A fast, lightweight embeddable scripting language
-
lead_lang_interpreter
Interpreter of the Lead Programming Language
-
vcc
Valkyrie Compiler Collection
-
telltale-vm
Bytecode VM for choreographic session type protocols
-
logic-ir
Universal Tri-Axial Fractal Topology (ZYModel) implementation in Rust
-
ezc
A compiler for ez
-
prexcl
esoteric proof-of-concept programming language
-
unimarkup
CLI for the Unimarkup compiler
-
rusty-handlebars-parser
Rust source generator for rusty-handlebars templates
-
umbra-lang
macro-based scripting language
-
wrecc_compiler
used by wrecc to compile C99 to x86-64
-
treeedb-souffle
Generate Datalog facts from Soufflé source code
-
lift-hybrid
LIFT compiler hybrid dialect: classical-quantum data encoding and joint gradient computation
-
pfcl-interpreter
Tree-walking interpreter for PFCL — pure functions, List<Command> effects
-
ternlang-hdl
Verilog-2001 codegen for balanced ternary — BET processor primitives, sparse matmul array, FPGA simulation wrapper
-
nyar_ast
-
air-script-core
Core types for the AirScript compiler
-
mrdo
A programming language (compiler, assembler, VM, and REPL) for working with collections of data
-
sollua
An elegantly fast lua 5.4 parser
-
decy
CLI tool for C-to-Rust transpilation with EXTREME quality standards
-
rlci
Overly-documented Rust-powered Lambda Calculus Interpreter
-
ironplc-plc2x
Compiler front-end for ironplc
-
llvm-lib
LLVM library with safe and flexibility in mind, without over complexity based on LLVM-C API
-
midenc-hir-opt
parsing and rewriting HIR
-
nodespeak
A JIT-ish compiler for number-crunching applications
-
beadie-backend
JitBackend trait, BackendAdapter, BoundBead, and TieredAdapter
-
thinkinglanguage
CLI entry point for ThinkingLanguage (tl run, tl shell)
-
full_moon
A lossless Lua parser
-
lmntalc-core
Backend-neutral compiler core for lmntalc
-
typlite
Converts a subset of typst to markdown
-
jzero-parser
LR(1) parser for the Jzero language
-
mutica-core
Core library for the Mutica programming language
-
neptune-lang
An embeddable scripting language
-
kbvm-cli
A CLI for working with XKB
-
oak-d
High-performance incremental D language parser for the oak ecosystem with flexible configuration, supporting systems programming and native development
-
logo-interp
Implements parsing and interpreting of Logo programming language
-
portal-pc-waffle-frontend
Frontend (Wasm to IR) for the WAFFLE Wasm analysis framework
-
netsblox-vm
running NetsBlox code with optional native extensions
-
quicklatex
A program to help me write LaTeX quickly
-
oak-cpp
C++ systems programming language parser with support for modern C++ features and object-oriented programming
-
petr-bind
The binding stage of the petr compiler
-
oxur
Lisp dialect that treats Rust as its compilation target and runtime
-
oxc_semantic
A collection of JavaScript tools written in Rust
-
bytor
A small WIP programming language
-
tale_lib
A Scripting language for TTRPG Tables
-
zhc_pipeline
ZHC: Compilation pipeline
-
rust-codegen
builder API for generating Rust code
-
orchidlang
An embeddable pure functional scripting language
-
llvm-ir-analysis
Static analysis on LLVM IR
-
i8051-debug-tui
A TUI for debugging the i8051 microcontroller emulator
-
draxl-rust
Rust language adapter for Draxl
-
rtlola-streamir
A framework for the compilation of stream-based languages through an intermediate representation
-
monkey-compiler
a compiler for monkeylang
-
mica
user-friendly, embeddable scripting language
-
intent-ir
Agent IR lowering, verification, and audit bridge for IntentLang
-
flycatcher-parser
The Flycatcher programming language's parser
-
wren-rs
Embed the Wren programming language in your Rust program
-
valua-core
Orchestrates the full valua transpile pipeline (lex → parse → transform → codegen)
-
tatara-lisp-lint
— typed, pluggable rule engine that lints .tlisp source against semantic Rules over the real tatara-lisp AST (read_spanned). Each rule is one trait impl; the first, GitMutationResultDiscarded…
-
stak-r7rs
Stak Scheme primitives for R7RS
-
forked_react_compiler_validation
Rust port of the React Compiler, vendored from react/react
-
haskelujah-th
Template Haskell AST types, Q monad, reification, and splice evaluation for the Haskelujah compiler
-
mir-rs
FFI bindings to MIR Project (https://github.com/vnmakarov/mir)
-
ruschm
Scheme(R7RS-small) interpretor/compiler rust implementation
-
px-llvm-codegen-utils-version-macros
Version macros for LLVM codegen utilities
-
ellie_bytecode
Bytecode assembler/encoder/decoder for ellie language
-
oak-javascript
JavaScript frontend for Oak (reuses TypeScript implementation)
-
ty-parser_sln
SLN-syntax parser for the Ty programming language
-
pcre2-sys
Low level bindings to PCRE2
-
galvan-parse
The parsing crate for the compiler of the Galvan programming language
-
zerodds-idlc
ZeroDDS IDL4 compiler CLI — Backends fuer C, C++, C#, Java, Python, Rust ueber zerodds-idl-* Codegen-Crates
-
elworthy-weight
Bismut-Elworthy-Li weight synthesis for elworthy
-
b3
port of B3 WebKit codegen backend
-
ccarp
(trans)Compile C And Rust Partially
-
airl-patch
Semantic patch engine for AIRL IR: apply, validate, and invert structural edits
-
decomp
Components of a decompilation pipeline
-
miden-assembly-syntax-cst
Lossless concrete syntax tree support for the Miden Assembly language
-
flaneur2020/pua-lang
a dialect of The Monkey Programming Language
-
tvm
Rust frontend support for TVM
-
fervid
Vue SFC compiler written in Rust
-
go-engine
The wrapper of the Goscript project
-
abrase-cli
CLI for the Abrase language
-
sp1-constraint-compiler
Constraint compiler for SP1 core machines
-
hannibal-lexer
DFA based Lexer written in Rust
-
dusklang
contains a compiler for the Dusk programming language
-
conventional_commits
A lightweight parser following the conventional commit standards
-
nand7400
An assembler library for the nand7400 computer, created by me during my internship at the WCL
-
easyjsc
easyjs to JS/wasm compiler
-
makepad-live-compiler
Makepad platform live DSL compiler
-
tsz-common
Common types and utilities for the tsz TypeScript compiler
-
hlvm
/ tools
-
tin
statically structurally typed embeddable programming language
-
runmat-kernel
Jupyter kernel implementation for RunMat using ZeroMQ and the Jupyter protocol
-
oris
An interpreter for Monkey
-
pflow-dsl
S-expression DSL for defining token model schemas
-
lolcode
C compiler
-
tidepool-codegen
Cranelift-based JIT compiler for Tidepool Core
-
flow_parser
Parser for the Flow programming language
-
rustz80
A restricted Rust -> Z80 compiler: the dialect is also real Rust; emits a bootable .tap. The cell micro-VM that runs the output lives in the
cell80crate. -
keleusma-cli
Standalone command-line frontend for Keleusma. Provides a script runner, a bytecode compiler, and an interactive REPL so users can work with Keleusma scripts without writing any Rust host code.
-
bfcomp
A compiler for BrainF*ck implemented with AWIB and bfcore
-
claw-codegen
The Claw language Wasm code generator
-
scriptplan-bash
Experimental Bash language parser and runtime for
-
oak-kotlin
Kotlin language support for Oak
-
tblis-ffi
FFI bindings of TBLIS
-
gen-polyglot
gen — polyglot workspace dispatcher. Probes a directory for every configured adapter marker and emits a typed PolyglotWorkspace containing one Manifest per detected language. Engines…
-
lift-predict
LIFT compiler performance prediction: analytical roofline model and budget enforcement for GPU/QPU workloads
-
kodept-parse
compiler with dependent types support in mind
-
tiny_lang_parser
A tiny language parser and interpreter for simple math expressions
-
bock-types
Type system, type checking, and inference for the Bock language
-
mllc
Compiler library for mata-ll: compiles a Haskell subset to a single self-contained Lua file. Bundles its standard library, so it needs no files on disk at runtime.
-
espy
a functional, embeddable scripting language
-
sqry-lang-vue
Vue language plugin for sqry
-
typed-eval
A type-safe expression evaluation engine
-
parselite
Recursive-descent parser harness with the depth guard baked in: deeply nested input returns a diagnostic, never a stack overflow
-
wesley-emit-typescript
TypeScript syntax-model emitter for Wesley IR
-
toy_share
Toylang development macros
-
edlc_docs
HTML renderer for documentation for the EDL compiler
-
b2c2-stat
デバッグ用にところどころで使ってるぽい
-
rustc-ap-rustc_fs_util
Automatically published version of the package
rustc_fs_utilin the rust-lang/rust repository from commit 9a27044f42ace9eb652781b53f598e25d4e7e918 The publishing script for this crate lives at: https://github… -
wysk
A statically typed functional language with type inference, ad-hoc polymorphism, and an extensible operator syntax. Influenced by Rust, ML, and Haskell.
-
tenda-scanner
Scanner for the Tenda programming language
-
nextjs_react_compiler_diagnostics
Rust port of the React Compiler, vendored from facebook/react
-
oak-php
PHP server-side scripting language parser with support for web development and modern PHP features
-
stck-interpreter
An interpreter for the stck language
-
rush-interpreter-vm
A rush interpreter leveraging a micro-compiler alongside a VM for its runtime
-
koto_memory
Memory management utilities used by the Koto programming language
-
ablescript_cli
The best programming language
-
tanlang
namespace for tanlang-org crates
-
dora-parser
The Dora programming language
-
steel-doc
Document generation for steel
-
vexil-codegen-ts
TypeScript code generation backend for the Vexil schema compiler
-
plato-dynamic-locks
Runtime lock accumulation — learns constraints from compilation/experience runs, extending static gates with dynamic knowledge
-
golang-type-name
Golang TypeName
-
genotype_core
Genotype language core crate
-
masl_ast
Maduka Authorization Specification Language (MASL) toolchain and runtime
-
jit
Just-In-Time Compilation in Rust using LibJIT bindings
-
code_highlighter
Highlights code for printing
-
oak-lean
Lean theorem prover language parser with support for dependent types and formal verification
-
bdwgc-sys
Boehm-Demers-Weiser garbage collector bindings for Rust
-
tinymist-debug
Tinymist debug support for Typst
-
cranefack
An optimizing brainfuck compiler
-
symboscript-types
A symbolic programming language SymboScript types
-
glulx-asm
Assembler for the Glulx Virtual Machine for Interactive Fiction
-
myriad-rs
VM runtime for Polka bytecode, computation core
-
prism-compiler
An adaptive and functional programming language
-
moore-svlog
The SystemVerilog implementation of the moore compiler framework
-
rascal_vm
Rascal programming language virtual machine
-
rajac-diagnostics
Diagnostic reporting infrastructure for rajac
-
calyx-utils
Compiler Infrastructure for Hardware Accelerator Generation
-
riscv_analysis_cli
RISC-V static analysis tool -- CLI
-
vize_vitrine
Vitrine - The display case for Vize (Node.js/WASM bindings)
-
comment
Strip comments for multiple programming languages
-
mago-semantics
PHP Semantics Checker
-
kbvm
XKB specification
-
oak-msil
Microsoft Intermediate Language (MSIL) parser with support for .NET Common Language Infrastructure and bytecode analysis
-
cowlang
Python-like scripting language
-
molt
Embeddable TCL interpreter for Rust applications
-
pl_0
pl/0 compiler implemented in rust
-
jsyc-compiler
Rusty-JSYC (JavaScript bYtecode Compiler) is a JavaScript-To-Bytecode compiler written in Rust. The bytecode is meant to be used in conjunction with the provided virtual machine (https://github…
-
lisette-stdlib
Little language inspired by Rust that compiles to Go
-
typst-realize
Typst's realization subsystem
-
petr-typecheck
the typecheck stage of the petr compiler
-
kotlin-parser
Kotlin Language Parser (WIP)
-
depyler
A Python-to-Rust transpiler focusing on energy-efficient, safe code generation with progressive verification
-
mindfuck
Brainfuck interpreter in Rust
-
crispy
a lisp enterpreter
-
mesa3d
Rust API to mesa3d project (compiler, command submission)
-
rustc-ap-rustc_ast_passes
Automatically published version of the package
rustc_ast_passesin the rust-lang/rust repository from commit 9a27044f42ace9eb652781b53f598e25d4e7e918 The publishing script for this crate lives at: https://github… -
inline-vbs
Embed VBScript (and JScript, Ruby, Perl, ...) code inside Rust
-
oak-koka
Koka frontend for Oak
-
shader-slang-sys
FFI bindings for the Slang shader language compiler
-
treeedbgen-souffle-souffle
Generate Soufflé types and relations from the Soufflé tree-sitter grammar
-
refrain-adapters
Differential Refrain Engine: output adapters (audio, visual, code, text)
-
mindblown
Brainfuck to x86 ELF compiler with batteries included
-
oak-llvm-ir
High-performance incremental LLVM IR parser for the oak ecosystem with flexible configuration, supporting low-level intermediate representation analysis
-
hebi
A dynamic scripting language
-
oxc_span
A collection of JavaScript tools written in Rust
-
voce-compiler-wasm
Voce IR WASM compiler — compiles state machines and compute nodes to WebAssembly
-
synoema-parser
Synoema — programming language optimized for LLM code generation
-
assura-codegen
Rust code generation from type-checked Assura contracts
-
airl-compile
Cranelift JIT compiler and WASM backend for AIRL IR
-
ape_errors
error handlers for Aperture programming language
-
pyoxidizer
Package self-contained Python applications
-
sorth
Forth inspired interpreted programming language
-
gluon_completion
Auto-completion for the gluon programming language
-
py-rustitude
create and operate models for particle physics amplitude analyses
-
scout-json
JSON representation of ScoutLang AST
-
python-mod
Proc-macros that compile Python modules into Rust at build time (the Rython toolchain)
-
datex-core
The DATEX Core Rust implementation
-
sateko
A toy brainfuck compiler
-
vc-ltl
Shared to msvcrt.dll or ucrtbase.dll and optimize the application file size
-
farmfe_utils
farm utils
-
findpython
Find python executables on your system
-
mica-std
The standard library of Mica, a simple, user-friendly, embeddable scripting language
-
cilk
(Toy) Compiler Infrastructure inspired by LLVM
-
zymodel
Universal Tri-Axial Fractal Topology (ZYModel) implementation in Rust
-
ruau-vm
The Ruau VM: a pure-Rust, async, sandboxed executor for Luau bytecode
-
cxx-llvm-auto
cxx-auto generated cxx bindings for cxx-llvm
-
petr-resolve
resolution stage of the petr compiler
-
mojo-rs-mojom
Mojom language toolchain: lexer, parser, AST, imports, module resolution, semantic validation. Accepts upstream .mojom corpora.
-
polonius
Core definition for the Rust borrow checker
-
brink-source-tree
SourceTree trait: a host-agnostic seam for enumerating and reading .brink source files
-
ape_lexer
lexical analysis for Aperture programming language
-
oak-ocaml
OCaml functional programming language parser with support for modern OCaml features and type system
-
dash-lang
interpreted language
-
compile-in-memory
dynamically compile and load C/C++ code at runtime, using the platform's host compiler
-
rspack
-
fexpresso
A minimal Kernel/vau-calculus Lisp with first-class operatives and environment-based IO
-
lex-trace
Run-time trace tree + replay for Lex programs
-
valua-lexer
Lua 5.5 tokenizer for the valua transpiler (Lua 5.4 is a supported subset)
-
graphcal-eval
Type-safe, unit-aware, Git-friendly reactive programming language for engineering calculations
-
rajac-lexer
Java lexer for the rajac compiler
-
graphcal-compiler
Type-safe, unit-aware, Git-friendly reactive programming language for engineering calculations
-
bfup
Preprocessor for brainfuck-like languages
-
intent-implement
AI-powered full implementation generation from IntentLang specifications
-
koi-macros
koi programming language rust integration macros
-
distrustc-server
A Rust-compatible distcc implementation
-
vyre-debug
Debugging CLI and inspection helpers for Vyre programs, lowering, and emitted shaders
-
omnilua-cli
Every Lua, everywhere — pure-Rust Lua 5.1–5.5, suite-passing, LuaRocks-compatible, wasm-ready
-
gnu-libjit
A safe rust wrapper around the libjit just in time compiler
-
calcit_runner
Interpreter and js codegen for Calcit
-
monkey-rs
Monkey programming language interpretter
-
onion-frontend
Compilation frontend for the Onion programming language - lexer, parser, and IR generator
-
t-repl
Shared REPL infrastructure for T and Ty compilers
-
guardc
GUARD → FLUX verified compiler
-
squirrel-sys
FFI bindings to the squirrel language
-
llvmkit-asmparser
Lexer and parser for LLVM textual IR (.ll), mirroring llvm/lib/AsmParser
-
hcb2lua_decompiler
A decompiler for HCB scripts to Lua
-
wrought
compiler
-
valua-codegen
Lua 5.1 code emitter for the valua transpiler
-
adana-script-core
namespaces aliases for command lines & basic scripting language
-
fennec-common
Fennec Programming Language
-
rascal_cli
A parser and compiler for Flash ActionScript 2 files into SWFs
-
cxc
A high performance scripting language
-
metaltile
Rust DSL for writing Apple Metal GPU kernels — write once, run fast on Apple Silicon
-
maat_span
Source span and location types for the Maat compiler
-
petr-cli
command line tool for compiling petr code
-
citadel-frontend
The frontend of the citadel compiler backend
-
cxx-llvm-build
Common build code for cxx-llvm
-
forgellm-codegen-wasm
WASM + WebGPU code generation for ForgeLLM
-
remolt
Embeddable TCL-ish interpreter for Rust applications
-
bynk-ide
Bynk's IDE/LSP analysis surface: non-bailing single-file and project diagnostics over the captured bynk-check tables — the surface the language server consumes
-
smelt-codegen-rust
Rust source-code generation from Smelt MIR
-
numbat-cli
A statically typed programming language for scientific computations with first class support for physical dimensions and units
-
swc_js_sourcemap
Basic sourcemap handling for Rust
-
stap-lang
Stap programming language (STAck Processor, ala Lisp)
-
evmlite
EVM bytecode assembler (two-pass label resolution, minimal-width push, init wrapper) plus a minimal dependency-free EVM-subset interpreter as its diff-oracle
-
marigold-grammar
Grammar for the marigold language
-
ratel
JavaScript transpiler in Rust
-
lora-analyzer
Semantic analysis for parsed Cypher queries in LoraDB
-
tlisp
Lisp interpreter in Rust
-
vyre-intrinsics
Cat-C hardware intrinsics for vyre - ops that require a dedicated Naga emitter arm and dedicated vyre-reference eval arm. Pure fn(...) -> Program builders over vyre::ir::* live in vyre-libs or user crates, not here.
-
runmat-logging
Structured logging and tracing utilities for RunMat hosts
-
calyx-opt
Compiler Infrastructure for Hardware Accelerator Generation
-
h2lang
H2 Language - A Herbert Online Judge compatible programming language with multi-agent support
-
utigo
package manager for C++
-
carlo-help
A help utility for the simple interpreted programming language Carlo
-
codespan
Data structures for tracking locations in source code
-
eridani
Pure functional scripting, anywhere
-
rustc_codegen_nvvm
A codegen backend for Rustc which targets the libnvvm CUDA library
-
libxas
Extendable Assembler library
-
forked_react_compiler_reactive_scopes
Rust port of the React Compiler, vendored from react/react
-
qxq
A playground for interpreters and JIT compilers
-
type-sitter-proc
procedural macros for type-sitter (generate typed wrappers for tree-sitter grammars from node-types.json and queries)
-
xlang-syntax
The xlang parser and syntax utilities
-
stak-time
Time library for Stak Scheme
-
mscoree_sys_2
Bindings for the mscoree.dll symbols. Windows-only.
-
lexviz
A customizable lexical analyser tool which also allows you to visualize the NFAs and DFAs generated
-
funcscript
universal core runtime (Rust VM) with C ABI and CLI
-
swamp-source-map
Source map cache for Swamp
-
barfs
Befunge JIT
-
stella_checker
Rust-based, speedy Lua type checker
-
remir_llvm
The LLVM binding for the Remir library
-
emlex
A zero-cost S-expression mathematical DSL engine for Rust. Provides compile-time evaluation, AST preservation, optimization, and reverse DSL reconstruction.
-
as3razen
compiler
-
sora-diagnostics
powerful configuration table compiler for games and data-heavy tools
-
luallaby
Work in progress A pure-Rust Lua interpreter/compiler
-
leo-interpreter
Interpreter for the Leo programming language
-
rust-bf
A Brainfuck interpreter, generator, REPL, and IDE written in Rust
-
makepad-live-tokenizer
Makepad platform live DSL tokenizer
-
sap-interpreter
The interpreter crate for the SAP programming language
-
plexer
A Pattern-matching LEXER
-
portalis-cli
CLI for Portalis - GPU-accelerated Python to Rust/WASM transpiler
-
yagbas_srcfiletypes
types for reading in yagbas source files
-
kind-span
Describes locations for the Kind compiler
-
typescript-types
Type definitions for TypeScript compiler
-
ssa-cc
Traits for compiling SSA IR to C
-
hugr-model
Data model for Quantinuum's HUGR intermediate representation
-
lisper
Lisp interpreter in Rust
-
greengold
A Forth bytecode interpreter library
-
sqry-lang-lua
Lua language plugin for sqry
-
miden-objtool
Common utilities for analyzing Miden artifacts
-
genotype_json_schema
Genotype language JSON Schema crate
-
befunge-colored
A rust-powered interpreter for the befunge-colored esolang
-
lolli-cli
Command-line interface for the Lolli linear logic workbench
-
mangle-driver
Driver for Mangle compilation pipeline
-
logicaffeine-cli
largo — the LOGOS build tool: new/init/build/run/check/verify/publish for logicaffeine projects
-
bougie-php-discovery
Discover and probe system PHP interpreters for bougie
-
forked_react_compiler_inference
Rust port of the React Compiler, vendored from react/react
-
peepmatic
DSL and compiler for generating peephole optimizers
-
qprime
An experimental programming language for quantum and weather calculations/applications
-
lumen-vm
The AI-Native Programming Language
-
python-assembler
Parse and write Python .pyc bytecode
-
monty-cli
A sandboxed, snapshotable Python interpreter written in Rust
-
bftextmaker
generate brainfuck code that prints out a given string
-
llvm-in-rust-ir
Core LLVM-inspired intermediate representation data structures and builders for LLVM-in-Rust
-
rtaichi
Rust language binding to the Taichi Runtime C-API
-
llvm-alt
A wrapper for LLVM, a powerful library and toolkit for compilers
-
lminc
An assembler and interpreter for the Little Minion Computer model created by Professor Magnus Bordewich of Durham University, based on the Little Man Computer created by Dr. Stuart Madnick of M.I.T. in 1965
-
ternlang-runtime
Distributed actor runtime for ternlang — TCP-based TernNode with remote spawn/send/await over newline-JSON protocol
-
retrolang
systems programming language compiler for Z80 microprocessors
-
satellite-jit
LLVM JIT compilation for ABI-OP constraints
-
tket2-hseries
TKET2 tool for preparing and validating
Hugrs for compilation targeting Quantinuum H-series quantum computers -
fervid_napi
Vue SFC compiler written in Rust
-
xlang_frontend
Frontend for XLang-Rust
-
graphix-stdlib
A dataflow language for UIs and network programming, standard library
-
brainfrick
An optimizing brainfuck interpreter with helpful errors
-
lincoln
A low level programming language features linear types and direct manipulation of continuation (returning points)
-
caixa-fmt
Canonical formatter for tatara-lisp / caixa sources
-
intarsia-build
Build helpers for compiling ISLE rulset files in build scripts for Intarsia optimizers
-
intent-check
Semantic analyzer and type checker for IntentLang specifications
-
petr-vm
a basic VM for running and debugging petr IR
-
hematita
A memory safe Lua interpreter
-
amble_script
Authoring-focused DSL, parser, and compiler that produces Amble engine WorldDef data
-
hephasm
Assembler for Asmodeus architecture with macro support and extended instructions
-
pcb
Pink Compiler Backend: Language agnostic compiler backend - Rust Library
-
seraphine-core
Core of the seraphine programming language
-
toy_ast
The toylang compiler AST
-
tidepool-eval
Tree-walking interpreter for Tidepool Core
-
swamp-node
compiler node with documentation and meta information
-
haloumi-picus
Haloumi backend to the Picus Constraint Language
-
steel-rc
Biased reference counting implementation for steel
-
pulley-interpreter
The Pulley interpreter, its bytecode definition, encoder, decoder, and etc
-
maat_prover
Zero knowledge STARK prover and verifier for the Maat programming language
-
luaur-compile-cli
Command-line Luau source-to-bytecode compiler (Rust)
-
sylt-common
Common denominator for the Sylt programming language crates
-
binks
scripting language
-
llvm_stackmap
capable of parsing stack maps emitted by the LLVM compiler
-
vtl-rs
Very Tiny Language (VTL) in Rust, inspired by the historical VTL-2 on Altair 680b and others
-
kodept-macros
compiler with dependent types support in mind
-
rji
Generates an efficient and seamless Rust/Java bridge. A Rust-Java Interface.
-
miden-field-repr
Serialization/deserialization for felt representation
-
bytebeat-cli
An LLVM-powered program to JIT-compile bytebeats and play them through your speaker
-
rascal_compiler
Rascal programming language compiler
-
numlang
A compiler for an esolang that uses hexadecimal
-
swc_ecma_transforms_base
rust port of babel and closure compiler
-
typst-library
Typst's standard library
-
extractor
Experimental API to extract the general error title of the compiler
-
ial-ast
ial's Abstract Syntax Tree
-
oil-lang
OIL
-
bock-parser
Parser for the Bock language, producing AST nodes from token streams
-
emei
JIT/AOT backend codegen framework
-
nextjs_react_compiler_ssa
Rust port of the React Compiler, vendored from facebook/react
-
masl_ir
Maduka Authorization Specification Language (MASL) toolchain and runtime
-
brainfuck-exe
A brainfuck interpreter implemented in rust
-
oak-nim
Nim language parser with support for modern Nim syntax and systems programming features
-
cuda-forth
Minimal Forth agent language
-
cucumber-expressions
Cucumber Expressions AST and parser
-
python-packaging
Python packaging primitives implemented in Rust
-
blink_core
Core interpreter for the Blink Lisp dialect
-
logi_code
A scripting language do executing combinational circuits
-
tishlang_cranelift_runtime
Runtime for Cranelift-compiled Tish bytecode
-
riscv_analysis
RISC-V static analysis tools
-
safety-pass
Compiler pass infrastructure for safety-net
-
lunar-lang
Lunar is a compiler that generate mruby bytecodes from Lua script
-
vyre-grammar-gen
Host-side C11 grammar table generator for the vyre GPU C parser. Emits DFA lexer + LR(1) action/goto tables as binary blobs that vyre-libs::parsing loads as ReadOnly buffers.
-
tket2
Quantinuum's TKET2 Quantum Compiler
-
impral
A command parsing and evaluation library for a LISP dialect, specialized for commandline input
-
prima-academy
Academic course classification primitives for Prima
-
claw-ast
The Claw language Abstract Syntax Tree (AST)
-
oak-scala
High-performance incremental Scala parser for the oak ecosystem with flexible configuration, supporting functional programming and JVM ecosystem integration
-
genotype_visitor
Genotype language visitor crate
-
moore-circt
Rust wrappers around the CIRCT API
-
logo-runtime
Implements the runtime for graphic functionality of Logo programming language
-
pfcl-typechecker
Hindley-Milner type inference for PFCL's content-addressed function catalog
-
oxc_minifier
A collection of JavaScript tools written in Rust
-
forked_react_compiler_diagnostics
Rust port of the React Compiler, vendored from react/react
-
flycatcher
programming language
-
flow_transpiler
Transpiler infrastructure for the Flow programming language
-
rajac-token
Token definitions for the rajac Java frontend
-
calyx-stdlib
Compiler Infrastructure for Hardware Accelerator Generation
-
oak-r
R statistical programming language parser with support for data analysis, statistical computing, and graphics
-
depyler-analyzer
Static analysis and optimization engine for Depyler
-
jzero-ast
Syntax tree data structures for the Jzero compiler
-
wmlua-src
wmlua
-
inc
Incremental approach to compiler construction
-
rlisp
experimental lisp interpreter in rust
-
bicycle_compiler
A compiler for Pauli-based compilation (PBC) circuits to bicycle instructions
-
ojisan_fuck
Brain-fuck interpreter parsing emoji used by Japanese ojisans
-
elworthy-diff
Symbolic differentiation for elworthy expression trees
-
safe_wren
A safe, pure-rust implementation of wren.io, drop-in replacement for wren.io's C implementation
-
garnish_lang_runtime
Runtime and execution library for Garnish Lang
-
moalinker
为 aarch64/riscv64 生成统一内核链接脚本
-
gust-build
Cargo build-script integration for compiling Gust .gu files during cargo build
-
llmcc-python
llmcc: llm context compiler
-
tsz-scanner
TypeScript scanner/tokenizer for the tsz compiler
-
koto_regex
A Koto library for working with regular expressions
-
synoema-types
Synoema — programming language optimized for LLM code generation
-
loxcraft
A compiler, VM, language server, and online playground for the Lox programming language
-
betadin
programing language for research purposes
-
assura-smt
SMT-based verification for Assura contracts via Z3
-
panproto-llvm
LLVM IR protocol definition and lowering morphisms for panproto
-
evalexpr-jit
JIT compilation and symbolic differentiation of evalexpr expressions with Cranelift
-
draxl-validate
Structural validation for Draxl source files
-
voce-compiler-ios
Voce IR iOS compiler — compiles IR to SwiftUI code with VoiceOver accessibility
-
luna-runtime-helpers
Static-link runtime entry for AOT-produced binaries. Exposes a single C-ABI symbol
luna_aot_run(bytecode, len) -> i32that constructs a lunaVm,undumps the embedded bytecode… -
stationeers-mips
Intermediate representation for Stationeers MIPS assembly
-
rtlola-streamir-interpreter
An interpreter for RTLola through StreamIR
-
jonlang
basic scripting language made to learn rust
-
rslint_parser
An extremely fast ECMAScript parser made for the rslint project
-
csw-derive
Type system derivation engine for the Categorical Semantics Workbench - derive type theories from categorical structures
-
eirproject/libeir_syntax_core
Erlang ecosystem common IR
-
wesley-emit-rust
Rust syntax-model emitter for Wesley IR
-
clr-assembler
Modern CLR assembler for x64 and x86 instruction sets - strongly typed, object-oriented, zero-dependency core
-
sylt-machine
VM for running programs in the Sylt programming language
-
yggdrasil-error
Yggdrasil shared error handlers
-
lex-runtime
Effect handler runtime + capability policy for Lex
-
typed
type annotation for compiler plugins
-
swc_experimental_ecma_parser
An extensible Rust-based platform for the next generation of fast developer tools
-
fervid_core
The core structures and utilities of fervid
-
parsit
very simple lib, the parsing combinators, recursive descendent that uses logos as lexer
-
maat_stdlib
Standard library sources for the Maat programming language
-
bif
Brainfuck Compiler
-
laspa
Lisp-like language built with Rust
-
citadel-api
The api for the citadel compiler backend
-
autolang
Auto is a programming language for automations in various scenarios
-
wave-compiler
WAVE compiler - compiles high-level kernel code to WAVE ISA binaries
-
tl-package
Package manager for ThinkingLanguage
-
tin-lang
tin: a statically structurally typed embeddable programming language
-
ape_env
environments for Aperture programming language
-
nope-lang
The nope programming language
-
scout-interpreter
A web crawling programming language
-
brink-runtime
Runtime/VM for executing compiled ink stories
-
kz80_prolog
Prolog compiler for Z80 - Logic programming on the RetroShield
-
brainfork
A compiler for Brainfuck written in Rust
-
sylt-typechecker
Typechecker for programs in the Sylt programming language
-
typst-eval
Typst's code interpreter
-
cxx-llvm-build-common
Common build code for cxx-llvm and dependent crates
-
py-ir
Pin1Yin1 ir implementation
-
rtlola2rust
A compiler from RTLola to Rust through StreamIR
-
rajac-ast
Abstract syntax tree definitions for the rajac Java compiler
-
relo
A custom programming language with a readable syntax (RELO)
-
flow_transpiler_java
Java bytecode transpiler for the Flow programming language
-
stak-sac
Stand-Alone Complex for Stak Scheme
-
treeedb-java
Generate Datalog facts from Java source code
-
tcpp
tcpp wrappings for c/cpp preprocessor
-
moa_memops
底层内存操作（clear_page 等）
-
otter-runtime
JavaScriptCore runtime for otter - TypeScript/JavaScript execution engine
-
airl-ir
Core IR data structures for AIRL (AI-native Intermediate Representation Language)
-
luna-lib
a light weight interpreted programming language
-
luajit
calling LuaJIT from Rust
-
forgellm-optimizer
Graph-level optimizations for ForgeLLM (fusion, layout, quantization, memory planning)
-
draxl-printer
Language-dispatch facade for Draxl rendering
-
kz80_db
dBASE II clone for Z80 - Retro database on the RetroShield
-
llvmkit
Rust reimplementation of LLVM IR APIs
-
tenda-common
Common utilities for the Tenda programming language
-
mago-project
representing and analyzing PHP projects. It parses PHP source files into ASTs, resolves names, collects semantic issues, and merges module reflections into a unified project reflection…
-
lambdust
A Scheme dialect with gradual typing and effect systems
-
macroassembler
writing portable x86-64/riscv64/aarch64 assembly code in Rust
-
lumen-provider-fs
The AI-Native Programming Language
-
expr-solver
Solves a mathematical expression while following precedence and associativity
-
leo-parser-lossless
Lossless syntax tree parser for the Leo programming language
-
js_parser
Javascript Parser : generate Aleph Syntax Tree
-
typst-timing
Performance timing for Typst
-
sqry-lang-shell
Shell script language plugin for sqry
-
reic
A compiler that just works
-
bf
An optimizing Brainfuck interpeter and JIT compiler
-
kasl
Parses and translates the kasl code into KASL-IR, an intermediate representation for KASL
-
claw-resolver
The Claw language name and type resolver
-
blazefuck
A blazingly-fast (interactive) Brainfuck interpreter
-
karnc
The Karn compiler — a typed function-then-context DSL that compiles to TypeScript
-
petr-utils
common utilities for the petr compiler and tooling
-
kind-target-kdl
KDL target for the kind compiler
-
seax_scheme
Scheme compiler for the Seax VM
-
ternlang-ml
Ternary ML inference kernels — TritFloat (confidence-native ternary float), TritFloatTensor, sparse_matmul (@sparseskip), TritMatrix, deliberation engine, action gate, and MLP for the Ternlang ecosystem
-
gnulightning-sys
Rust bindings for gnulightning jit compiler
-
rl-cranelift
Cranelift-based JIT compiler backend for the rl-lang programming language
-
cxx-llvm
cxx-style FFI bindings to the LLVM C++ API
-
oak-racket
Hand-written Racket frontend
-
mtots
scripting language
-
kodept-inference
compiler with dependent types support in mind
-
petr-ir
target agnostic IR for the petr language
-
alicorn
Rust embedding of the Alicorn compiler
-
phenotyper-cli
CLI for the Phenotyper compiler
-
genotype_writer
Genotype language writer crate
-
bhc-intern
String interning for efficient symbol handling
-
calyx-frontend
Compiler Infrastructure for Hardware Accelerator Generation
-
cte_ir
Compile-time evaluation IR
-
erg_type
APIs for Erg types
-
lua_engine
lua engine
-
kasm
The Kerbal Compiler Collection assembler for kOS
-
py-codegen-c
C codegen backend implementation for Pin1Yin1
-
bock-codegen
Multi-target code generation for Bock — JS, TS, Python, Rust, Go
-
everust
Evaluates rust code
-
ruchy
A systems scripting language that transpiles to idiomatic Rust with extreme quality engineering
-
jit-sys
libjit in rust
-
target-lexicon
LLVM target triple types
-
enalang_ir
Exhaustingly Notorious Algorithms - intermediate representation definition
-
molt-ng
Embeddable TCL interpreter for Rust applications ()
-
jit_rs
jit.rs is a library for generating, optimizing and running executable code at runtime
-
bop-cli
CLI and REPL for the Bop programming language
-
ezno
A fast and correct TypeScript type checker and compiler with additional experiments. For use as a library or through the CLI
-
llvm-rs
A wrapper for LLVM, a powerful library and toolkit for compilers
-
gluon_format
Code formatting for the gluon programming language
-
spade-hir-lowering
Helper crate for https://spade-lang.org/
-
baracuda-nvrtc-sys
Raw FFI bindings and dynamic loader for NVIDIA NVRTC (runtime CUDA-C++ to PTX compiler)
-
unidades
playing with physical units
-
monty-fs
A sandboxed, snapshotable Python interpreter written in Rust
-
egglog-reports
egglog is a language that combines the benefits of equality saturation and datalog. It can be used for analysis, optimization, and synthesis of programs. It is the successor to the popular rust library egg.
-
sqry-classpath
JVM classpath analysis for sqry - bytecode parsing, build system resolution, and graph integration
-
ldpl
LDPL 4.4 compiler in Rust
-
bfjit
Brainfuck JIT VM tutorial
-
jzero-symtab
Symbol table types for the Jzero compiler
-
masl_formatter
Maduka Authorization Specification Language (MASL) toolchain and runtime
-
metaltile-core
Core IR types and data structures for the MetalTile GPU kernel DSL
-
n-rustc-codegen-cranelift-pre-t-x64-win-msvc-p1
Segment rustc-codegen-cranelift-preview.target.x86_64-pc-windows-msvc part p1
-
sap-lexer
The lexer crate for the SAP programming language
-
oak-von
Valkyrie language parser with support for modern Valkyrie syntax and features
-
xassembler
Compiler tools for the xasm programming language
-
synth-cli
CLI for Synth, the WebAssembly-to-ARM Cortex-M AOT compiler
-
lolli-prove
Proof search for the Lolli linear logic workbench
-
silt-lua
A pure rust Lua interpreter and virtual machine
-
rush-parser
A lexer and parser for the rush programming language
-
oxc_traverse
A collection of JavaScript tools written in Rust
-
symboscript-lexer
SymboScript lexer
-
gust-mcp
Model Context Protocol (MCP) server exposing the Gust compiler to AI-assisted development tools
-
oak-jasmin
Jasmin Java assembler parser with support for Java bytecode assembly and class file generation
-
haloumi-backend
Generic backend API of the haloumi framework
-
carbon-assembler
An assembler for the carbon CPU
-
mech-time
Time library for the Mech language
-
moonlift
A pure-rust implementation of Lua (5.4) with just-in-time (JIT) compilation using
cranelift -
op8d_lexemizer
Opinionated library for transforming code to a vector of Lexemes
-
brainease_transpiler
A brainf*ck-style programming language, but readable
-
luah
Unofficial lua impl by HydroRoll-Team
-
seax
SECD virtual machine for interpreting programs in FP languages and a Scheme compiler targeting that machine
-
flow_runtime
Runtime library for the Flow programming language
-
vicuna-compiler
A compiler for the Vicuna programming language
-
carlo-version
Version for the simple interpreted programming language Carlo
-
flow_compiler
JIT and AOT compiler for the Flow programming language using Cranelift
-
intent-gen
Natural language to IntentLang spec generation via LLM (Layer 0)
-
ylc
Ygens ir compiler
-
rustpython-compiler-core
RustPython specific bytecode
-
citadel-middleend
The middleend/optimizer for the citadel compiler backend
-
xlang_vm_core
XLangVM for XLang-Rust
-
llvm-in-rust-target-x86
x86-64 target backend for LLVM-in-Rust code generation
-
graphcal-plugin-abi
Type-safe, unit-aware, Git-friendly reactive programming language for engineering calculations
-
stak-native
Optimized primitives of native functions for Stak Scheme
-
tl-data
Data engine for ThinkingLanguage — DataFusion, connectors, I/O
-
llts
TypeScript to native compiler via LLVM
-
brink-syntax
Syntax types and parser for inkle's ink narrative scripting language
-
mica-hl
High-level interface to the Mica scripting language
-
bynk-render
Bynk's shared diagnostic-rendering layer: ariadne human output and the short/json forms over bynk-syntax::CompileError. The presentation layer both CLI front-ends adopt so they render identically.
-
cardinal-c
A C target for the Cardinal code generator
-
draxl-parser
Language-dispatch facade for Draxl parsing
-
bfkit
A Brainfuck toolkit
-
valua-transformer
AST mutation passes that lower Lua 5.5 features to Lua 5.1 equivalents
-
symboscript-optimizer
SymboScript optimizer
-
dpy
transpiler to translate dutch python like code to working python code
-
voce-adapter-vercel
Voce IR Vercel deployment adapter — Build Output API v3
-
tsz-emitter
TypeScript-to-JavaScript emitter and transforms for the tsz compiler
-
c-lang
Scripting language made in rust
-
crain
A Brainfuck compiler/interpreter/tool
-
diatom-cli
The diatom programming language
-
eirproject/libeir_intern
Erlang ecosystem common IR
-
refrain-core
Differential Refrain Engine core: DSL parser and AST
-
csw-core
Core categorical structures for the Categorical Semantics Workbench - define categories and derive type systems
-
polyglot_interpreter
A cross-platform, cross-language interpreter of simple logical expressions
-
synoema-core
Synoema — programming language optimized for LLM code generation
-
seher
official crate
-
suffete
A standalone PHP type system: representation, comparison, and type checking primitives for static analysis tools
-
monkey-evaluator
a evaluator for monkey lang
-
sym-lang
Sym Lang is a lightweight stack-based programming language that uses symbols and numbers
-
swc_ecma_transforms_proposal
rust port of babel and closure compiler
-
comet-rs
Rust eDSL for COMET: domain specific COMpiler for Extreme Targets
-
ano_jit_bfi_rs
Outdated Just-In-Time BrainFuck Interpreter written in RuSt
-
cas-vm
Virtual machine that executes CalcScript bytecode
-
vexc
Compiler and toolchain for the Vex programming language
-
bund_stdlib_text_classifier
Text classification using Bayes classifier for BUND programming language
-
typst-ide
IDE functionality for Typst
-
carlo-run
A runner for the simple interpreted programming language Carlo
-
mica-language
Reference implementation of the Mica scripting language
-
hclua-src
hclua
-
bfmod
Brainfuck lexer and compiler library for Rust
-
runmat-core
Host-agnostic RunMat execution engine (parser, interpreter, and JIT integration)
-
tinywasm
A tiny WebAssembly interpreter
-
mlua-image
Lua bindings and embedding of the Rust based 'image' imaging library
-
skeletree-core
Domain types shared across Skeletree: symbols, edges, ids. Zero I/O.
-
xlang
interpreter engine
-
boa_ast
Abstract Syntax Tree definition for the Boa JavaScript engine
-
forgellm-runtime
Minimal runtime for ForgeLLM (KV cache, sampling, tokenizer, API server)
-
nyar-assembler
Modern Nyar VM assembler - strongly typed, object-oriented, zero-dependency core
-
fast-rustc-ap-rustc_target
Automatically published version of the package
rustc_targetin the rust-lang/rust repository from commit 15812785344d913d779d9738fe3cca8de56f71d5 The publishing script for this crate lives at: https://github… -
jsompiler_common
Common utilities for jsompiler
-
assura-pipeline
Shared compiler pipeline for the Assura language
-
luaparser
Read Lua 5.1 code and produce an abstract syntax tree
-
bock-lexer
Tokenizer for the Bock language
-
sloppy
A binary package to run sloppy script
-
ternlang-moe
Ternary Mixture-of-Experts orchestrator (MoE-13). Dual-key routing, triad synthesis, safety hard gate, three-tier memory, 13-agent deliberation. DOI: 10.17605/OSF.IO/TZ7DC
-
symboscript-utils
SymboScript utils
-
mini-lang
A minimal, experimental language for lazy evaluation
-
hush
unix shell scripting language based on the Lua programming language
-
ullage
Programming Language
-
hugr-persistent
Persistent IR structure for Quantinuum's HUGR
-
tools_core
Core functionality and schema generation for the tools collection system
-
ubpf-assembler
eBPF assembler and JIT compiler for ubpf
-
fennec-parser
Fennec Programming Language
-
jasm-assembler
Modern assembler for JVM instruction set - strongly typed, object-oriented, zero-dependency core
-
eqmap
Technology Mapping w/ E-Graphs
-
luar
Lua interpreter implemented in Rust
-
cyclang-parser
Cyclang is a toy language built in LLVM
-
petr-pkg
package management for the petr language
-
kodept-interpret
compiler with dependent types support in mind
-
ruau-runner
Bounded multi-tenant request runner for Ruau
-
moore-svlog-hir
The HIR of the SystemVerilog implementation of the moore compiler framework
-
nextjs_react_compiler_optimization
Rust port of the React Compiler, vendored from facebook/react
-
bf-compile
A compiler for BrainFuck
-
irvm-lower
The lowering library for IRVM to go to LLVM IR
-
forked_react_compiler_optimization
Rust port of the React Compiler, vendored from react/react
-
oak-voml
Valkyrie language parser with support for modern Valkyrie syntax and features
-
runmat-repl
Interactive RunMat REPL with line editing and Jupyter kernel integration
-
simple-vm
bytecode VM with a custom compiler
-
blink_runtime
Runtime lib for creating plugins for blink
-
lunir
A universal intermediate representation oriented towards Lua
-
weavy
Shared lowered-program substrate for interpreters and copy-and-patch backends
-
py-codegen
pycc-rs codegen interface
-
oak-mojo
Mojo frontend for Oak
-
oxc_ast_visit
A collection of JavaScript tools written in Rust
-
glass-easel-template-compiler
The template compiler of the glass-easel project
-
kaon
A little scripting language written in rust
-
bicycle_common
Common definitions for bicycle architecture compiler crates
-
llts_codegen
LLTS codegen — LLVM IR generation via Inkwell
-
stak
Stak Scheme interpreter
-
oak-javadoc
Javadoc documentation language parser with support for API documentation generation and code analysis
-
oak-rst
High-performance incremental reStructuredText parser for the oak ecosystem
-
treeedb-cpp
Generate Datalog facts from C++ source code
-
tinymist-project
Project model of typst for tinymist
-
emmylua_parser
A parser for EmmyLua and luals
-
tenda-prelude
Prelude for the Tenda programming language
-
autoken-rustc
A rust-lang static analysis tool to automatically check for runtime borrow violations
-
tur
Turing Machine Language - Parser, interpreter, and execution engine
-
maat_air
CPU constraint system (AIR) for the Maat programming language
-
enalang_optimizer
Exhaustingly Notorious Algorithms - optimizer
-
bsharp_lsp
The B# programming language!
-
math-jit
Compile arithmetic expressions to native code
-
masl_lsp
Maduka Authorization Specification Language (MASL) toolchain and runtime
-
exers
compiling and running other code in sandboxed environment
-
calyx-backend
Compiler Infrastructure for Hardware Accelerator Generation
-
maat_lexer
DFA-based lexer for the Maat programming language
-
rusty_utils
package that provides utility functions inspired by or ported from other programming languages
-
tinymist-query
Language queries for tinymist
-
ion-derive
Derive macro for Ion scripting language host types
-
husk-types
Type definitions for the Husk programming language
-
tree-sitter-java
Java grammar for tree-sitter
-
tl-ai
AI/ML integration for ThinkingLanguage — tensors, training, inference, LLM
-
rajac-classpath
Classpath loading and symbol extraction for rajac
-
graphcal-lsp
Language Server Protocol implementation for Graphcal
-
boolfuck
unoptimized boolfuck interpreter which can convert brainfuck code
-
easter
Type definitions for ECMAScript abstract syntax trees
-
luajit2-sys
LuaJIT-2.1 FFI Bindings
-
kind-query
Query module for the kind compiler
-
wasi-assembler
Modern assembler for WASM and WASI (wit-component) - strongly typed, object-oriented, zero-dependency core
-
llvm-in-rust-target-riscv
RISC-V target backend for LLVM-in-Rust code generation
-
genotype_lang_rs_core
Genotype language Rust target core crate
-
julia
Idiomatic and safe Julia bindings for Rust
-
noxue-compiler
利用docker实现在线编译运行代码
-
ruby
Pure Rust implementation of Ruby runtime environment
-
brink-ide
Protocol-agnostic IDE query library for inkle's ink
-
steel-interpreter
Steel repl and command line interface
-
swamp-layout
Memory layout calculation for Swamp ABI types, handling size, alignment, and efficient representation of data structures
-
mech-system
System library for the Mech language
-
decy-codegen
Rust code generation from HIR with minimal unsafe blocks
-
enalang_macro
Exhaustingly Notorious Algorithms - macro support
-
gluac-rs
compiling Garry's Mod Lua into bytecode
-
mux-runtime
Runtime library for the Mux programming language
-
gust-runtime
Runtime support library (traits, envelopes, supervisors) for programs compiled from Gust
-
depyler-corpus
Deterministic scientific corpus analysis for Python-to-Rust transpilation quality measurement
-
pfcl-types
Core value types for PFCL: Value, Hash (SHA-256), runtime environment
-
clue_core
C/Rust like programming language that compiles into Lua code
-
lucia-lang
Lucia programming language
-
arithmetic-eval
interpreter for arithmetic expressions
-
tsz-checker
TypeScript type checker for the tsz compiler
-
gluon_repl
REPL for gluon. A static, type inferred programming language for application embedding
-
symjit
a lightweight just-in-time (JIT) optimizer compiler
-
pk_parser
The Palacinke lang parser
-
llvm-pm-sys
Raw FFI bindings for LLVM new PassManager C++ stubs
-
refrain-egraph
Differential Refrain Engine: egglog rewrite engine bindings
-
gnu-libjit-sys
Rust bindings for libjit compiler
-
lld_rs
Bindings for LLD
-
brainfuck_macros
A compiler plugin that converts brainfuck code into Rust at compile time, letting your BF programs be optimised by LLVM to super-fast native code
-
synoema-eval
Synoema — programming language optimized for LLM code generation
-
cfla-cli
Command-line interface for the compact functional low-level assembler, cfla, a declarative functional systems programming language
-
llts_driver
LLTS driver — pipeline orchestration from TypeScript to native
-
gluon_check
The typechecker for the gluon programming language
-
voce-adapter-static
Voce IR static deployment adapter — plain dist/ folder output
-
eadup
A native-first markup language and EADUP compiler for automated, standards-compliant document typesetting
-
bynk-lsp
bynkc-lsp — the Language Server for the Bynk DSL
-
llts_frontend
LLTS frontend — oxc parser and semantic analysis wrappers
-
ape_expr
abstract syntax tree for Aperture programming language
-
haskelujah-core
Core language, desugaring, and simplification for the Haskelujah compiler
-
bock-fmt
Source code formatter for the Bock language
-
bsharp_interp
The B# programming language!
-
liblox
VM of the lox language
-
enalang_repl
Exhaustingly Notorious Algorithms - repl
-
lolli-codegen
Code generation for the Lolli linear logic workbench
-
darklua-demo
Transform Lua scripts
-
haskelujah-span
Source offsets, file IDs, byte-offset spans, and span arithmetic for the Haskelujah compiler
-
lulz
A fast and spec-compliant LOLCODE implementation
-
aiscript-directive
Directives of AIScript programming language interpreter
-
llvm-sys-wrapper
Shallow wrapper for llvm-sys
-
mirrc
MIRR compiler — a safety-critical DSL for hardware-software co-design targeting SystemVerilog RTL
-
unfuck
Python 2.7 bytecode deobfuscator
-
inline-python
Inline Python code directly in your Rust code
-
ternlang-codegen
C transpiler backend for the Ternlang compiler — emits C source from the Ternlang AST for native cross-compilation targets
-
stak-compiler
Stak Scheme bytecode compiler
-
dora
programming language
-
logicaffeine-data
WASM-safe data structures and CRDTs - NO IO
-
tinylj
calling LuaJIT from Rust
-
llvm-ir-taint
Taint tracking for LLVM IR
-
treeedb-php
Generate Datalog facts from PHP source code
-
mano
An assembler and emulator library for the Mano Machine RISC CPU
-
typst-bundle
Bundle exporter for Typst
-
elworthy-codegen
Cranelift lowering of elworthy expression trees
-
forked_react_compiler_ssa
Rust port of the React Compiler, vendored from react/react
-
swc_ecma_react_compiler
SWC helpers for the React Compiler
-
synth-core
Core types, error handling, and backend trait for the Synth compiler
-
brainease_lexer
A brainf*ck-style programming language, but readable
-
ternlang-test
Test harness and assertion utilities for ternlang programs — BET-VM test runner, trit assertions, and golden-file diffing
-
nextjs_react_compiler_validation
Rust port of the React Compiler, vendored from facebook/react
-
xlang-vm
A virtual machine for running Xlang programs
-
bicycle_benchmark
Generates PBC circuits that can be used for benchmarking
-
genotype_runtime
Genotype runtime
-
rustd_backend_llvm
LLVM backend for RustD deterministic DSL compilation
-
mlua-xid
A Rust-native binding for the 'xid' crate for Rust
-
pfcl-parser
Parser for PFCL — pure functional language with content-addressed catalog
-
rustpython-bytecode
RustPython specific bytecode
-
lia-plugin
Compiler plugin for writing Lia code as a macro
-
symboscript-interpreter
SymboScript interpreter
-
haloumi-core
Core types and traits of the Halo2 frontend for LLZK
-
rustpython-parser
Python language parser for Python3
-
beadie-llvm
LLVM JIT backend adapter for beadie (via inkwell)
-
orecc-front
compiler frontend utility toolkit
-
yeller
The best programming language ever
-
draxl-lower-rust
Lower validated Draxl Rust-profile files to ordinary Rust
-
gluon_doc
The documentation generator for the gluon programming language
-
tinymist-task
Task model of typst for tinymist
-
sljit-sys
System crate for sljit using bindgen and ast-grep
-
rong_path
Path module for RongJS
-
masl_linter
Maduka Authorization Specification Language (MASL) toolchain and runtime
-
mun
Command-line interface for compiling, monitoring and running Mun code
-
ryna-ffi
FFI interface for the Ryna Programming Language
-
bop-compile
Ahead-of-time Bop to Rust source transpiler
-
tokay
programming language designed for ad-hoc parsing
-
bsharp_ir
The B# programming language!
-
libsix
Compact programming language built on top of Rust ecosystem
-
atlasc
The Atlas77 Compiler
-
seraphine-cli
CLI for the Seraphine programming language
-
rajac-parser
Java parser for the rajac compiler
-
oxc_syntax
A collection of JavaScript tools written in Rust
-
portalis-transpiler
Python to Rust transpiler engine with WASM compilation support
-
swc_es_codegen
High-performance code generator for swc_es_ast
-
haloumi-llzk
Haloumi backend to LLZK
-
llvm-in-rust-transforms
Optimization and transformation passes for LLVM-in-Rust IR
-
cemc
Cem language compiler - A concatenative language with green threads and linear types
-
tl-errors
Error types and diagnostics for the ThinkingLanguage compiler
-
regen-lang
A language for defining languages
-
molt-argparse
The argument parser generator macro for the Rust-based Tcl interpreter, Molt
-
llvm-sys-featured
Bindings to LLVM's C API
-
terl
a general parser
-
treeedb-python
Generate Datalog facts from Python source code
-
tsz-lowering
AST-to-type lowering bridge for tsz
-
bock-interp
Tree-walking interpreter for the Bock language, used by
bock runand tests -
molt-app
Molt Shell Application
-
assura-runtime
Runtime contract monitoring for Assura-generated Rust code
-
brink-db
Incremental project database for inkle's ink narrative scripting language
-
guile-scheme
A small wrapper around the Guile Scheme Extension and Scripting Language
-
vicis
Manipulate LLVM-IR in Pure Rust
-
cranelift-simplejit
JIT library backed by Cranelift
-
synth-verify
SMT translation validation for the Synth compiler (ordeal QF_BV engine; optional Z3 differential oracle)
-
kz80_bc
Arbitrary-precision decimal arithmetic language and calculator for Z80
-
wasmer-clif-fork-simplejit
JIT library backed by Cranelift
-
petr-api
re-exports of useful APIs for the petr compiler
-
gust-stdlib
Standard library of reusable Gust state machines (circuit breaker, retry, saga, rate limiter, and more)
-
decy-ownership
Ownership and lifetime inference for C-to-Rust conversion (CRITICAL)
-
whenever-parser
A parser for David Morgan-Mar's Whenever language (http://www.dangermouse.net/esoteric/whenever.html)
-
voce-compiler-android
Voce IR Android compiler — compiles IR to Jetpack Compose with TalkBack accessibility
-
stak-build
Build scripts for Stak Scheme
-
depyler-ruchy
Ruchy script format backend for Depyler Python-to-Rust transpiler
-
destack-rs
Rust compatibility crate for Destack
-
synoema-lexer
Synoema — programming language optimized for LLM code generation
-
maroon
Scheme-inspired lisp that compiles to Lua
-
forked_react_compiler_typeinference
Rust port of the React Compiler, vendored from react/react
-
kast
kast programming language
-
dsp56300
assembler, disassembler, and JIT emulator
-
retrolang-asm
Z80 assembler for RetroLang (based on FantASM by Guy Black)
-
moore-circt-sys
Low-level language bindings to CIRCT
-
heartfelt
Heartfelt A simple Rust library for creating DSLs (Domain Specific Languages) Roadmap This is still pretty much a work in progress. There will soon be an update with examples and documentation…
-
coopted_llvm_sys
Coöpt rustc‘s own LLVM to do fancy stuff with it
-
vyre-foundation
Foundation layer: IR, type system, memory model, wire format. Zero application semantics. Part of the vyre GPU compiler.
-
airlang_ext
The Extension of Air Programming Language
-
steel-repl
REPL library for steel
-
swamp-vm-layout
Memory layout calculation for Swamp VM types, handling size, alignment, and efficient representation of data structures
-
lift-config
LIFT compiler configuration: .lith language parser and validator, O0-O3 optimisation pipeline presets
-
leo-span
Span handling for the Leo programming language
-
prooflite
The litelite reference language: total, fuel-bounded, output-capped. Every program halts within its fuel — by construction.
-
machina
Manage and execute assembly at runtime
-
spec-checker
Property-based and runtime-gate checker for Lex specs
-
lolli-parse
Parser for the Lolli linear logic workbench
-
josie-core
High-performance core runtime for JOSIE (JSON Omni Safe Interactive Expressions), with deterministic tree-based pipeline execution and embeddable operator/function registries
-
norn
High-level compiler library
-
nexus-lang-cli
Command-line interface and REPL for the Nexus network description language
-
bytebeat-rs
bytebeat binary
-
evalit
a toy interpreter
-
runmat
High-performance MATLAB/Octave syntax mathematical runtime
-
runtime-lexer
regex based lexer
-
typst-macros
Proc-macros for Typst
-
lexariel
Lexical analyzer for Asmodeus language
-
oort-vm
The Oort Virtual Machine
-
ts-runtime-typechecker
A command line tool that generates ts/js typechecker functions from typescript types
-
oxc_mangler
A collection of JavaScript tools written in Rust
-
mir-sys
FFI bindings to MIR Project (https://github.com/vnmakarov/mir)
-
jzero-lexer
Lexer for the Jzero language (a subset of Java)
-
rajac-verification
OpenJDK compatibility verification runner for rajac
-
rajac-compiler
Compiler pipeline orchestration for rajac
-
cyclang-backend
Cyclang is a toy language built in LLVM
-
airl-interp
Tree-walking interpreter for AIRL IR with 74 builtins
-
vexity
Tiny scripting language for hacking on abstractions of financial markets
-
genotype_lang_core_codegen
Genotype language target codegen crate
-
swc_compiler_base
Base crate for the 'swc' crate. This is not a public API.
-
refrain-rhizome
Differential Refrain Engine: Loro CRDT bridge (optional)
-
pk_vm
The Palacinke lang bytecode virtual machine
-
pfcl-resolver
Name resolver for PFCL: resolves catalog names to SHA-256 hashes at load time
-
tl-lexer
Lexer/tokenizer for ThinkingLanguage
-
monty-typeshed
A sandboxed, snapshotable Python interpreter written in Rust
-
brainheck
interpreter written in Rust
-
bund_stdlib_analysis
Numeric and text analysis for BUND programming language
-
px-llvm-codegen-utils-core
Core traits for LLVM codegen utilities
-
logicaffeine-kernel
Pure Calculus of Constructions type theory - NO LEXICON
-
pfcl-catalog
Content-addressed function catalog for PFCL — identity is SHA-256 of typed source
-
stak-profiler
Profiling for Stak Scheme
-
aiscript-lexer
The lexer of AIScript programming language interpreter
-
llvm-in-rust-analysis
Control-flow, call-graph, dominance, loop, and use-def analyses for LLVM-in-Rust IR
-
brink-fmt
Source code formatter for inkle's ink narrative scripting language
-
tsz-lsp
Language Server Protocol implementation for the tsz compiler
-
vyre-lints
Lego-block enforcement lints for vyre. Forbids raw IR construction in dialect crates.
-
decy-verify
Safety property verification for transpiled Rust code
-
psi-lang
A language for configuration and extension
-
kind-report
Report module for the kind compiler
-
shedron
A DSL for dice rolls
-
oak-vbnet
VB.NET parser for the Oaks framework
-
llvmkit-support
Shared support utilities for the llvmkit family (Span, Spanned, SourceMap)
-
nextjs_react_compiler_utils
Rust port of the React Compiler, vendored from facebook/react
-
py-lex
lex definition for pycc-rs
-
bock-lsp
Language Server Protocol implementation for the Bock language
-
treeedb-go
Generate Datalog facts from Go source code
-
cpast
Run custom testcase with powerful clex language powered generated tool. Ideal for competitive coders. Can test two file and pass & match randomly generated outputs
-
chan-lang
Chan Programming Language
-
qwik-core
Qwik optimizer compiler
-
maat_runtime
Runtime value system for the Maat programming language
-
haskelujah-backend-cranelift
Cranelift native code backend for the Haskelujah Haskell compiler
-
genotype_lang_py_codegen
Genotype language Python target codegen crate
-
bsharp
The B# programming language!
-
vm_lang
interpreted language written in Rust
-
llir
LLVM IR Binding
-
rustyscript
Effortless JS Integration for Rust
-
numeron
Neron is a language designed to be as simple as possible
-
llvm-bitcode
LLVM Bitcode parser in Rust
-
rlvm
LLVM wrapper
-
tur-cli
Command-line interface for Turing machine simulator
-
oxc_parser_napi
A collection of JavaScript tools written in Rust
-
starfish
*><> is a stack-based, reflective, two-dimensional esoteric programming language based directly off of ><>
-
beadie-cranelift
Cranelift JIT backend adapter for beadie
-
stir
Small Threaded Intermediate Representation
-
tenda-runtime
Runtime support for the Tenda programming language
-
flow_lexer
Lexical analyzer for the Flow programming language
-
tinymist-l10n
Localization support for tinymist and typst
-
voce-adapter-netlify
Voce IR Netlify deployment adapter
-
mogi_cpu
CPU emulation core for MOGI
-
tree-sitter-python
Python grammar for tree-sitter
-
libjit-sys
Just-In-Time Compilation in Rust using LibJIT bindings
-
riddle-lang
RiDDLe is a language for the definition of timeline-based domains and problem definitions, designed to facilitate the integration with solvers and to increase modularity and reusability of domain models
-
tishlang_js_to_tish
Vanilla JavaScript to Tish AST converter
-
stak-dynamic
Dynamic primitives for Stak Scheme
-
maat_codegen
Bytecode code generation for the Maat programming language
-
ternlang-cli
Command-line interface for ternlang — run, build, sim, fmt, repl, and compat commands for the Balanced Ternary Execution VM
-
swc_experimental_ecma_semantic
An extensible Rust-based platform for the next generation of fast developer tools
-
jcompiler
a compiler for the J programming language
-
masl_compiler
Compiler, code generator and semantic validator for the Maduka Authorization Specification Language (MASL)
-
treeedb-swift
Generate Datalog facts from Swift source code
-
waspy
A Python to WebAssembly compiler written in Rust
-
synoema-diagnostic
Synoema — programming language optimized for LLM code generation
-
typst
A new markup-based typesetting system that is powerful and easy to learn
-
tinymist-analysis
Typst Static Analyzers for Tinymist
-
py-codegen-llvm
llvm codegen backend implementation for Pin1Yin1
-
tl-lsp
Language Server Protocol implementation for ThinkingLanguage
-
tessellate-core
Compiler and deterministic runtime for the Tess rule language
-
brink-analyzer
Cross-file semantic analysis for inkle's ink narrative scripting language
-
oak-bat
High-performance incremental Windows Batch (BAT) parser for the oak ecosystem with flexible configuration, supporting shell scripting and automation workflows
-
yes-lang
Scripting Language
-
portal-jsc-common
ECMAScript IR
-
llvm-in-rust-target-arm
AArch64 target backend for LLVM-in-Rust code generation
-
hugr-core
Quantinuum's Hierarchical Unified Graph Representation
-
quickjs-rusty
QuickJS (QuickJS-NG) Javascript engine wrapper, and more
-
bock-build
Build pipeline for Bock projects, coordinating parse, check, codegen, and target compilation
-
maat_types
Hindley-Milner type inference engine for the Maat programming language
-
assura-macros
Proc macros for inline Assura contract annotations in Rust
-
w16-core
Ядро W16
-
tsz-solver
TypeScript type solver for the tsz compiler
-
synth-backend-aarch64
AArch64 (A64) host-native backend for synth — integer subset (milestone 1, #538)
-
decy-stdlib
C standard library prototypes for the Decy C-to-Rust transpiler
-
depyler-analysis
Analysis, type inference, and optimization passes for the Depyler transpiler
-
oxc_isolated_declarations
A collection of JavaScript tools written in Rust
-
stak-inexact
Inexact number operations for Stak Scheme
-
thinkinglanguage-types
ThinkingLanguage — Type system and type checker
-
bock-ai
AI provider interface for Bock's AI-native code generation pipeline (Generate, Repair, Optimize, Select)
-
teko-rs
Command line interface for Teko
-
fck
Brainfuck parser, lexer and interpreter
-
metaltile-runtime
Apple Metal runtime dispatch for MetalTile GPU kernels
-
lolli-extract
Term extraction for the Lolli linear logic workbench
-
molt-shell
Molt Application Frameworks
-
melbi
expressive, embeddable, sandboxed expression language
-
bsharp_tokens
The B# programming language!
-
treeedb-rust
Generate Datalog facts from Rust source code
-
voce-adapter-cloudflare
Voce IR Cloudflare Pages deployment adapter
-
swc_ecma_transforms_react
rust port of babel and closure compiler
-
haloumi-ir-base
Types used by the IR and by some modules that the IR depends on
-
oxc_str
A collection of JavaScript tools written in Rust
-
luna-jit-helpers
Shared
luna_jit_*extern-C runtime helpers + per-thread JIT_VM/JIT_CL TLS slots +enter_jitRAII rebind for the goliajp/luna Lua runtime. Used by bothluna-jit(Cranelift backend)… -
ts-type
types for working with TypeScript type representations in Rust
-
carlo-repl
A REPL for the simple interpreted programming language Carlo
-
genotype_lang_rs_visitor
Genotype language Rust target visitor crate
-
brink-codegen-json
JSON codegen backend: LIR → ink.json format
-
bsharp_fset
The B# programming language!
-
bynk-strip
Strip-only TypeScript→JavaScript for Bynk's first-class JS artefact (the in-browser track). Erases TypeScript type syntax via oxc, preserving runtime semantics and all value imports;…
-
llvm-in-rust-ir-parser
Lexer and parser for LLVM textual IR into LLVM-in-Rust data structures
-
bock-vocab
Self-describing language vocabulary emitter for Bock — keywords, errors, prelude, stdlib, annotations
-
swc_ecma_transforms_optimization
rust port of babel and closure compiler
-
ternlang-compat
Compatibility bridges for the ternary ecosystem — .tasm 9-trit assembler → BET bytecode, Owlet S-expression front-end
-
stak-lzss
LZSS compression for Stak Scheme
-
tl-interpreter
Tree-walking interpreter for ThinkingLanguage (Phase 0)
-
maat_module
Module system and multi-file compilation for the Maat programming language
-
synoema-repl
Synoema — programming language optimized for LLM code generation
-
logicaffeine-verify
Z3-based static verification for Logicaffeine (requires Pro+ license)
-
rune-ssa
Intermediate mode representation for Rune
-
kind-driver
Driver for the kind compiler
-
metaltile-macros
Proc-macro crate providing the #[kernel] DSL for MetalTile GPU kernels
-
spade-types
Helper crate for https://spade-lang.org/
-
dynasm-lib
A pure rust assembler, not a JIT. Used within direct-asm for maximum control over assembly.
-
llvm_build_utils
Ever wanted to build “native” assembly stuff in your cargo build scripts… something gcc crate cannot quite handle yet? Welcome to llvm_build_utils which provides a convenient API to pack your…
-
tinymist-render
Rendering features for tinymist
-
cranelift-module
Support for linking functions and data with Cranelift
-
genotype_lang_rs_converter
Genotype language Rust target converter crate
-
brink-codegen-inkb
Bytecode codegen backend: LIR → StoryData (inkb format)
-
litto
Building blocks for DSL scripting language interpreters that interact with native Rust code
-
stak-configuration
Stak Scheme configuration
-
synth-opt
Peephole optimization passes for the Synth compiler
-
jit_macros
JIT Macros
-
oxc_data_structures
A collection of JavaScript tools written in Rust
-
litelite
A kit for purpose-sized languages: buy total verification with smallness. Diagnostics, lexing, parsing, fuel, and capability tables — the invariants paid once.
-
rustpython-pylib
A subset of the Python standard library for use with RustPython
-
oxc_regular_expression
A collection of JavaScript tools written in Rust
-
spydecy-c
C AST parser for Spydecy transpiler with CPython API recognition
-
tabulon_macros
Internal procedural macros for the tabulon expression engine
-
crityp
Benchmark support for typst
-
oak-zig
Zig language parser with support for modern Zig syntax and features
-
decy-repo
GitHub repository transpilation with parallel processing
-
swc_ecma_transforms_compat
rust port of babel and closure compiler
-
llvm-in-rust-bitcode
Compact bitcode reader and writer for LLVM-in-Rust IR modules
-
maat_eval
Tree-walking interpreter and macro expansion engine for the Maat programming language
-
jsompiler_lexer
Lexer for JavaScript
-
sixth
Programming language
-
intent-runtime
Expression evaluator and stateless runtime for IntentLang specifications
-
ezjs
micro Javascript (ES5) engine is Rust
-
lolli-viz
Visualization for the Lolli linear logic workbench
-
stak-module
Modules in Stak Scheme
-
voce-adapter-core
Voce IR deployment adapter trait and shared types
-
sim-lib-lang-ruby
Ruby-style surface profile for the SIM expression runtime
-
autophagy-llvm
LLVM backend for Autophagy
-
graphcal-plugin-macros
Type-safe, unit-aware, Git-friendly reactive programming language for engineering calculations
-
brink-converter
Converts inklecate .ink.json to brink .inkb format
-
oak-glob
Glob pattern language support for Oaks
-
stratlite
A total, fuel-bounded trading-strategy language: every decision halts within its fuel and look-ahead is unrepresentable. Pairs with backtestlite, its deterministic verifier.
-
teko
programming language implementation in Rust
-
oxc_diagnostics
A collection of JavaScript tools written in Rust
-
beadie-core
Bead chain, broker, hotness policy, swap, and deopt — no JIT backend
-
bsharp_parser
The B# programming language!
-
bock-pkg
Package management for Bock projects, including dependency resolution and lockfiles
-
decy-agent
Background daemon for incremental transpilation and watching
-
diaglite
Span + Diag diagnostics kernel for purpose-sized languages: byte spans, line/col, caret snippets that never panic on mid-char offsets
-
bock-core
Core stdlib registry and runtime primitives for the Bock language
-
cranelift
Umbrella for commonly-used cranelift crates
-
vyre-aot
Ahead-of-time compilation for vyre Programs: emits target-native bytes plus a self-contained launcher bundle suitable for embedded and competition-style code-budget-constrained submissions
-
synth-synthesis
WASM-to-ARM instruction selection and peephole optimizer
-
oak-asciidoc
High-performance incremental AsciiDoc parser for the oak ecosystem
-
autophagy
AOT compiler for Rust
-
tinymist-core
Tinymist core library
-
tsz-cli
CLI binaries for the tsz TypeScript compiler
-
brink-json
Parser for inklecate .ink.json output format
-
vicis-core
Manipulate LLVM-IR in Pure Rust
-
vicuna-runtime
Runtime for the Vicuna programming language
-
stak-minify
Stak Scheme source code minifier