-
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. -
starlark
language in Rust
-
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
-
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
-
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
-
harn-kernel
Portable compiler, program artifact, and deterministic execution kernel for Harn
-
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)
-
blitzgen
An optimizing x86-64 compiler backend: e-graph IR with equality saturation for instruction selection, a DAG scheduler, and a graph-coloring register allocator
-
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.
-
blue-lang-cli
The blue command line: run, fmt, ast, erase, check
-
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
-
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.
-
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
-
laddu
Amplitude analysis tools for Rust
-
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
-
zust-dynamic
Dynamic value model for Zust scripts, with JSON, MessagePack, bytes, and typed vectors
-
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
-
metaslang_stack_graphs
Stack graphs utilities used in Slang
-
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.
-
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
-
beamr
runtime with the BEAM's execution model, targeting Gleam
-
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
-
tket-qsystem
TKET tool for preparing and validating
Hugrs for compilation targeting Quantinuum H-series quantum computers -
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
-
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
-
gluon_vm
The virtual machine for executing the gluon programming language
-
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)
-
deed-explain
Generated pages for every diagnostic code deed can produce
-
parlex-gen
Lexer generator ALEX and parser generator ASLR
-
xlog-cuda
CUDA kernel provider, buffers, and interop for XLOG
-
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
-
harn-parser
Parser, AST, and type checker for the Harn programming language
-
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
-
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
-
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
-
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
-
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.
-
caixa-ast
Span-aware Lisp AST for the caixa ecosystem — shared by caixa-fmt, caixa-lint, caixa-lsp. Compatible with tatara-lisp's Sexp.
-
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
-
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
-
ocaml-gen
generating OCaml code
-
leo-abi
ABI generation for Leo programs
-
kn-runtime
Dynamic wrapper around CPU and GPU inference
-
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
-
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
-
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
-
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
-
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.
-
zia
Interpreter Library for the Zia Programming Language
-
single-variable-algebra-compiler
A compiler for the minimalistic programming language single-variable-algebra
-
tsz-parser
TypeScript parser and AST types for the tsz compiler
-
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
-
antimony-lang
The Antimony programming language
-
bund
Interpreter and CLI for a Virtual Machine for BUND programming language
-
xbasic64
A BASIC-to-x86_64 native code compiler targeting 1980s-era BASIC dialects
-
sema-core
Core types and environment for the Sema programming language
-
x86_64-assembler
Modern assembler for x64 and x86 instruction sets - strongly typed, object-oriented, zero-dependency core
-
junolsp
Language Server for JunoLang
-
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… -
vize_atelier_core
Atelier Core - The core workshop for Vize Vue template parsing, transform lanes, and code generation
-
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
-
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
-
zhc_utils
Shared utilities for the ZHC compiler
-
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
-
rl-vm
Bytecode virtual machine for the rl-lang programming language
-
sora-core
powerful configuration table compiler for games and data-heavy tools
-
awa5_rs
An AWA5.0 CLI tool written in Rust (btw)
-
qvcm
Register-based bytecode VM with quantum computing functionality
-
wright
programming language compiler and tooling
-
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
-
ast-demangle
Parses mangled names and produces structured results
-
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
-
ferro-jtype
Type inference for Java class bytecode without JDK symbols
-
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
-
ringkernel-cuda-codegen
CUDA code generation from Rust DSL for RingKernel stencil kernels
-
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
-
hiko-syntax
part of the hiko ML-family scripting language
-
espr
EXPRESS Language compiler
-
netidx-bscript
An incremental scripting language for netidx
-
typr
A typed superset of R - transpiler and type checker
-
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
-
tremor-script
Tremor Script Interpreter
-
runmat-vm
RunMat virtual machine and bytecode interpreter
-
hugr
Quantinuum's Hierarchical Unified Graph Representation
-
jzero
A compiler and bytecode VM for the Jzero language (a subset of Java)
-
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
-
vyre-lower
Substrate-neutral lowering: vyre Program → KernelDescriptor consumed by vyre-emit-* crates
-
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
-
llvm-in-rust-codegen
Machine-independent code generation infrastructure for LLVM-in-Rust
-
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
-
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
-
gluon_parser
The parser for the gluon programming language
-
ts-native
TypeScript to native executable compiler - Stable Release
-
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
-
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.
-
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
-
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…
-
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
-
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
-
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
-
swipl
A high-level library for building SWI-Prolog extensions and embedding SWI-Prolog in rust applications
-
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 the Noir compiler SSA pipeline
-
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 allocator for Noir compiler data structures
-
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
-
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
-
lux-lang
The Lux programming language
-
moa_bitops
位操作原语与动态大小位图
-
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
-
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
-
archscript
programming language — Python-like syntax, Haskell-inspired features, Arch Linux integration
-
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…
-
rosetta-stone-core
Core types and traits for the Rosetta transpiler
-
wasc
A C-like language compiler for WebAssembly with first-class support for references and tables
-
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
-
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
-
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 -
piccolo
Stackless Lua VM implemented in pure Rust
-
orco
A compiler backend interface
-
c64-assembler
Commodore 64 assembler, outputs directly to .PRG or Dasm source code
-
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.
-
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
-
metaltile-codegen
Metal Shading Language (MSL) code generator for MetalTile kernels
-
rl-lexer
Lexer and tokenizer for the rl-lang programming language
-
fidget-bytecode
Bytecode representation for Fidget expression tapes
-
astmap-languages
Language parsers and resolvers for astmap (tree-sitter based)
-
leo-std
Embedded Leo standard library source
-
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
-
vpratt
absolute zenith of pratt parsing
-
aleph-syntax-tree
Aleph Syntax Tree structure
-
ringkernel-ir
Intermediate Representation for RingKernel GPU code generation
-
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
-
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
-
harn-glob
Glob pattern matching primitives for the Harn programming language
-
omg_runtime
The OMG language runtime and virtual machine, providing bytecode execution, REPL, and built-in functions
-
mag_lang
The Mag Language Runtime
-
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
-
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…
-
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
-
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
-
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
-
gccjit_sys
Raw bindings to libgccjit. Companion to the gccjit crate.
-
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
-
leo-retriever
A retriever for the Leo programming language
-
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
-
rew-compiler
CoffeeScript/TypeScript compiler for the Rew runtime
-
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
-
sk-lang
The SK Programming Language interpreter
-
gluon_base
Basic type definitions and functions for the gluon programming language
-
send-future
Ergonomic and performant fix for https://github.com/rust-lang/rust/issues/96865
-
stak-process-context
Process context for Stak Scheme
-
sixu
Experimental Visual Novel Scripting Language
-
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
-
lisette-semantics
Little language inspired by Rust that compiles to Go
-
nmp-feed-session
Shared feed-session compiler for NMP runtimes
-
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
-
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
-
ale_python_parser
Python Parser : generate Aleph Syntax Tree
-
leo-abi-types
ABI type definitions for Leo programs
-
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
-
phoron_asm
A Jasmin-compatible Assembler for the JVM
-
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.
-
nightjar-lang
A declarative, prefix-notation DSL for formal verification of structured data
-
oak-html
HTML markup language parser with support for web content and document structure processing
-
bytevm
A tiny bytecode virtual machine
-
sora-config-format
powerful configuration table compiler for games and data-heavy tools
-
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
-
irvm
A IR compiler target with a Rust friendly API that lowers to LLVM IR
-
lancelot-bin
binary analysis tools for x32/x64 PE files
-
beadie
Hot-function promotion broker for interpreter-to-JIT tiering
-
nilang
A scripting language interpreter for Advent of Code
-
moa_rand
xoshiro256++ 伪随机数生成器
-
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
-
deed-ast
Syntax tree for the Deed language
-
paramodel-plan
Paramodel test-plan layer: TestPlan, Axis, ExecutionPolicies, OptimizationStrategy, TrialOrdering, plan-level bindings
-
ilex
quick and easy lexers for C-like languages
-
repl_lib
creating REPL interpreters
-
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
-
librasm
using RASM
-
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
A command-line Python to Rust compiler, at this point, very incomplete
-
libket
Runtime library for the Ket programming language
-
provekit_noirc_driver
Driver for the Noir compiler pipeline
-
michaelb/sniprun
A neovim plugin to run lines/blocs of code (independently of the rest of the file), supporting multiples languages
-
karaka-core
Karaka language core: lexer, parser, evaluator
-
rusm-jsc
Build-time QuickJS bytecode compiler for RUSM TS bundles (version-locked to the js-runner's rquickjs)
-
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
-
bicycle_numerics
Compute numerics for bicycle circuits
-
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)
-
blue-lang-runtime
The blue runtime — one definition of what a blue program runs against
-
sui-bytecode
Bytecode compiler and VM for the sui Rust-native Nix evaluator
-
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
-
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
-
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
-
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
-
verter_core
Vue 3 SFC compiler - transforms Vue Single File Components to render functions with TypeScript support
-
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
-
fta
Fast TypeScript Analyzer
-
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
-
valua-parser
Recursive-descent Lua 5.5 parser for the valua transpiler
-
garden-lang-parser
A live programming language
-
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)
-
aiscript-arena
safe, incrementally garbage collected arenas
-
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
-
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)
-
devsper-compiler
Distributed AI Swarm Runtime
-
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
-
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
-
abacus
The mathemagical programming language
-
lia
A high-level language for Rust
-
nadesiko3
Japanese programming language Nadesiko v3
-
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
-
sap-shared
The shared crate for the SAP programming language
-
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
-
axonml-jit
JIT compilation for Axonml tensor operations
-
dunh
Highlights code for printing
-
kind-pass
A lot of compiler passes for the kind compiler
-
intarsia
An extensible Rust optimization framework
-
telltale-machine
Protocol machine for choreographic session type protocols
-
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
-
deed-dap
A debug adapter for Deed
-
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
-
lift-core
LIFT compiler framework core: unified SSA intermediate representation (IR) for AI and quantum — types, values, operations, blocks, regions, verifier
-
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
-
koto_parser
The parser used by the Koto programming language
-
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
-
shavenscript
Lightweight programming language made in rust with support for array and basic operations
-
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
-
modu
A fast and simple turning-complete interpreted language
-
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
-
spade-diagnostics
Helper crate for https://spade-lang.org/
-
valua-lint
Static analysis lints for the valua transpiler. Public crate; stable from 1.0.
-
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
-
claw-common
The Claw language common types and functions
-
trashcan
language which compiles to Visual Basic 6 / VBA
-
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
-
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
-
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
-
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
-
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
-
aivm
Artificial intelligence that embraces the hardware it runs on
-
oakc
A portable programming language with a compact backend
-
rscheck-semantic
Semantic backend surface for rscheck
-
nlcc
Nameless C Compiler
-
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
-
lep
Mini language for interactive consoles, featuring small code footprint
-
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
-
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++
-
swift-precompiler
A precompiler for Swift that allows you to use additional macros, include files, and more
-
blitz_lang
A Hobby Programming Lang with Rust
-
hzlang_parser
A parser for the "hz" programming language
-
qvnt-qasm
A OPENQASM 2.0 Parser
-
roto
a statically-typed, compiled, embedded scripting language
-
paijorot
interpreted programming language implemented in Rust. It's designed as a hobby project with unique 'brainrot' syntax. ***(FULLY AI WRITTEN)***
-
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
-
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
-
nvvm
High level bindings to libnvvm
-
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
-
qcs-sdk-python
Python bindings to qcs-sdk-rust
-
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
-
gluon_c-api
C-api for gluon, a static, type inferred programming language for application embedding
-
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
-
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
-
songe
Interpreter for a Scheme-like language for graphics and games
-
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.
-
wrecc
A x86_64 C99 compiler written from scratch
-
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
-
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
-
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
-
cuda_builder
Builder for easily building rustc_codegen_nvvm crates
-
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 for 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
-
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
-
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的工具库,记录一些常用的工具函数
-
lift-opt
LIFT compiler pass manager: 13 optimisation passes — constant folding, DCE, CSE, tensor fusion, gate cancellation, qubit routing
-
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
-
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)
-
jitvm
a tiny i64-only language with a bytecode interpreter and a hand-rolled x86-64 jit
-
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.
-
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
-
hvm1
A massively parallel functional runtime
-
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
-
coda-runtime
the runtime for coda, an experimental scripting language
-
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)
-
lisette-emit
Little language inspired by Rust that compiles to Go
-
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
-
airlang_bin
Air is a universal, reliable, and lean programming language
-
vcompiler_tools
Some useful stuff for making simple compilers
-
art_documentation_demo
Just a demo from The Rust Programming Language book
-
bop-vm
Bytecode compiler and stack VM for the Bop programming language
-
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)
-
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
-
sassers
A Sass compiler in Rust
-
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
-
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
-
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
-
flow_analyzer
Semantic analyzer for the Flow programming language
-
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
-
lci
A LOLCODE interpreter written in Rust
-
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
-
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
-
rocalang
A contractual language for the AI era
-
flow_stdlib
Standard library for the Flow programming language
-
goxoy-interpreter
Sistem bilgisini veren kitaplik
-
koi-parser
koi programming language parser
-
monkey
Interpreter for the Monkey programming language
-
wavm-cli
A 64 bit register based virtual machine
-
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
-
lamina-ir
Lamina Intermediate Representation — high-level SSA IR for the Lamina compiler
-
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
-
duck-diag
Generic diagnostic engine for building rich error reporting into any tool
-
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
-
claw-cli
The compiler for the Claw language
-
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
-
ruau
Pure Rust implementation of Luau and its analyzer
-
syntax-rs
parsing programming languages
-
setjmp
/ longjmp support
-
dimpact
impact analysis from diff
-
evcxr_jupyter
A Jupyter Kernel for Rust
-
parser-c
Macros for parser-c
-
avdl
Avro IDL compiler that turns .avdl into .avpr and .avsc JSON files
-
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
-
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
-
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
-
kz80_ws
WordStar clone for Z80 - Retro word processor on the RetroShield
-
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
-
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
-
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
-
lwb-parser
parser framwork with automatically generated ASTs for the LWB project
-
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
-
open-vaf
A compiler frontend for VerilogA aimed predominently at compact modelling
-
brainfuck-plusplus
A brainfuck interpreter and compiler with some extra functionality
-
lazyk-rust
Interpreter for Lazy K programming language
-
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
-
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
-
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
-
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
-
tt-toolkit
A collection of macros for rapidly prototyping programming languages
-
kz80_ml
Tiny ML compiler for the Z80 processor with Hindley-Milner type inference
-
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
-
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
-
scala
A experimental Scala interpreter written in Rust: lexer, parser, type inference, and tree-walking evaluation with a REPL
-
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
-
masl_hir
Maduka Authorization Specification Language (MASL) toolchain and runtime
-
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
-
vyre-driver
Driver layer: registry, runtime, pipeline, routing, diagnostics. Substrate-agnostic backend machinery. Part of the vyre GPU compiler.
-
hel
HEL — Heuristic Expression Language: a deterministic, auditable expression language & parser, AST, builtin registry and evaluator
-
tetherscript
A dynamically-typed scripting language with Rust-style ownership, implemented as a bytecode VM in Rust
-
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
-
luaur-analysis
Luau type checker and type inference (Rust)
-
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
-
ringkernel-wgpu-codegen
WGSL code generation from Rust DSL for RingKernel
-
codegem
A small code generation library
-
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
-
wick-core
Core expression language for wick
-
distrustc-client
A Rust-compatible distcc implementation
-
lamina-mir
MIR (Machine Intermediate Representation) type definitions for Lamina
-
skiff
An immutability-first, functional scripting language with a friendly syntax and compiler/interpreter written in Rust!
-
c64-assembler-6502
Definition of 6502 instruction set
-
miden-package-registry-local
Filesystem-backed local package registry for Miden packages
-
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
-
leo-disassembler
A disassembler for the Leo programming language
-
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
-
kind-derive
Derive generator the kind compiler
-
elworthy-expr
Symbolic expression AST, canonicalisation, and CSE for elworthy
-
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 →…
-
w16-ir
Промежуточное представление w16, и оптимизации
-
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
-
quail
Programming Language
-
langbox
framework to build compilers and interpreters
-
scout-lexer
A web crawling programming language
-
lift-export
LIFT compiler backends: LLVM IR, ONNX (opset 21), OpenQASM 3 exporters; CUDA PTX and XLA planned
-
polka-rs
Bytecode schema for the Myriad runtime (Abrase language)
-
ana-lang
A small interpreted language
-
sp1-recursion-compiler
Compiler for SP1 recursion circuits
-
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
-
gust-lsp
Language Server Protocol (LSP) implementation for the Gust state machine language
-
cedar-policy-validator
Validator for the Cedar Policy language
-
ptx_compiler
High level bindings to CUDA's ptx compilation APIs
-
XLang-Rust
An experimental cross-platform dynamic strong-typed programming language written in Rust
-
tsz-binder
TypeScript name binder for the tsz compiler
-
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.
-
zinc-lang
Interpreter for the Zinc Programming Language
-
bynk-fmt
Formatter for the Bynk DSL (used by bynkc-lsp)
-
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
-
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
-
go-types
The type checker of the Goscript project
-
meadorc
meador scripting language compiler
-
brink-environment
The reified, content-addressed compilation Environment value plus the effectful Project/SourceTree producer (#1306)
-
monty-pool
A sandboxed, snapshotable Python interpreter written in Rust
-
provekit_noirc_errors
Error reporting 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
-
valua-diagnostics
Diagnostic types and reporting for the valua transpiler
-
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
-
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
-
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
-
rajac-symbols
Symbol tables and semantic symbol data for rajac
-
pycrust
A sandboxed python interpreter (and soon to be compiler)
-
gibberish-core
Core types and functions for Gibberish parsers
-
flycatcherc
The front-end of the Flycatcher compiler
-
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
-
rocks-lang
Crafting Interpreters' Lox Language
-
monkey-interpreter
an interpreter for monkeylang
-
tenda-parser
Parser for the Tenda programming language
-
symboscript-parser
SymboScript parser
-
ezno-checker
A fast and correct TypeScript type checker with additional experiments
-
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.
-
cjc-diag
Diagnostic infrastructure and error codes for CJC
-
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
-
kaledis_dalbit
A fork of a Luau-to-Lua transpiler based on darklua to use for kaledis
-
moore-common
The common core of the moore compiler framework
-
moss
Experimental Moss interpreter
-
ampc
Compiler for the Amp language
-
rust-guile
Scheme runtime in your Rust program
-
pfcl-interpreter
Tree-walking interpreter for PFCL — pure functions, List<Command> effects
-
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
-
source-span
Source code mapping and display utilities
-
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
-
ananse
WebAssembly-native zero-knowledge virtual machine (zkVM)
-
rusty-handlebars-parser
Rust source generator for rusty-handlebars templates
-
umbra-lang
macro-based scripting language
-
treeedb-souffle
Generate Datalog facts from Soufflé source code
-
callisp
A lisp interpreter that can be used with WASM
-
lift-hybrid
LIFT compiler hybrid dialect: classical-quantum data encoding and joint gradient computation
-
lift-sim
LIFT compiler static analysis: shape propagation, FLOP counting, memory analysis, noise simulation
-
portal-pc-waffle-frontend
Frontend (Wasm to IR) for the WAFFLE Wasm analysis framework
-
jeff-format
Rust bindings for the jeff exchange format
-
ternlang-hdl
Verilog-2001 codegen for balanced ternary — BET processor primitives, sparse matmul array, FPGA simulation wrapper
-
nyar_ast
-
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
-
oxur
Lisp dialect that treats Rust as its compilation target and runtime
-
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
-
vcc
Valkyrie Compiler Collection
-
typlite
Converts a subset of typst to markdown
-
wrecc_compiler
used by wrecc to compile C99 to x86-64
-
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
-
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
-
rtlola-streamir
A framework for the compilation of stream-based languages through an intermediate representation
-
petr-bind
The binding stage of the petr compiler
-
air-script-core
Core types for the AirScript compiler
-
monkey-compiler
a compiler for monkeylang
-
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
Compilation pipeline for HPU code generation
-
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
-
mica
user-friendly, embeddable scripting language
-
ironplc-plc2x
Compiler front-end for ironplc
-
intent-ir
Agent IR lowering, verification, and audit bridge for IntentLang
-
wren-rs
Embed the Wren programming language in your Rust program
-
lmntalc-core
Backend-neutral compiler core for lmntalc
-
valua-core
Orchestrates the full valua transpile pipeline (lex → parse → transform → codegen)
-
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
-
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
-
typed-eval
A type-safe expression evaluation engine
-
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
-
flycatcher-parser
The Flycatcher programming language's parser
-
scriptplan-bash
Experimental Bash language parser and runtime for
-
oak-kotlin
Kotlin language support for Oak
-
tblis-ffi
FFI bindings of TBLIS
-
tenda-scanner
Scanner for the Tenda programming language
-
kodept-parse
compiler with dependent types support in mind
-
tiny_lang_parser
A tiny language parser and interpreter for simple math expressions
-
tsz-common
Common types and utilities for the tsz TypeScript compiler
-
makepad-live-compiler
Makepad platform live DSL compiler
-
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.
-
sqry-lang-vue
Vue language plugin for sqry
-
sp1-constraint-compiler
Constraint compiler for SP1 core machines
-
graphcal-eval
Type-safe, unit-aware, Git-friendly reactive programming language for engineering calculations
-
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
-
claw-codegen
The Claw language Wasm code generator
-
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.
-
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
-
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
-
espy
a functional, embeddable scripting language
-
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…
-
genotype_core
Genotype language core crate
-
masl_ast
Maduka Authorization Specification Language (MASL) toolchain and runtime
-
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…
-
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
-
dora-parser
The Dora programming language
-
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
-
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…
-
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
-
lift-predict
LIFT compiler performance prediction: analytical roofline model and budget enforcement for GPU/QPU workloads
-
refrain-adapters
Differential Refrain Engine: output adapters (audio, visual, code, text)
-
cowlang
Python-like scripting language
-
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
-
scout-json
JSON representation of ScoutLang AST
-
mindblown
Brainfuck to x86 ELF compiler with batteries included
-
lisette-stdlib
Little language inspired by Rust that compiles to Go
-
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
-
zymodel
Universal Tri-Axial Fractal Topology (ZYModel) implementation in Rust
-
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
-
t-repl
Shared REPL infrastructure for T and Ty compilers
-
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
-
cilk
(Toy) Compiler Infrastructure inspired by LLVM
-
valua-lexer
Lua 5.5 tokenizer for the valua transpiler (Lua 5.4 is a supported subset)
-
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
-
ruau-vm
The Ruau VM: a pure-Rust, async, sandboxed executor for Luau bytecode
-
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
-
lift-config
LIFT compiler configuration: .lith language parser and validator, O0-O3 optimisation pipeline presets
-
onion-frontend
Compilation frontend for the Onion programming language - lexer, parser, and IR generator
-
guardc
GUARD → FLUX verified compiler
-
squirrel-sys
FFI bindings to the squirrel language
-
citadel-frontend
The frontend of the citadel compiler backend
-
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
-
maat_span
Source span and location types for the Maat compiler
-
petr-cli
command line tool for compiling petr code
-
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
-
swc_js_sourcemap
Basic sourcemap handling for Rust
-
metaltile
Rust DSL for writing Apple Metal GPU kernels — write once, run fast on Apple Silicon
-
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
-
runmat-logging
Structured logging and tracing utilities for RunMat hosts
-
calyx-opt
Compiler Infrastructure for Hardware Accelerator Generation
-
utigo
package manager for C++
-
carlo-help
A help utility for the simple interpreted programming language Carlo
-
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
-
stap-lang
Stap programming language (STAck Processor, ala Lisp)
-
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.
-
funcscript
universal core runtime (Rust VM) with C ABI and CLI
-
swamp-source-map
Source map cache for Swamp
-
barfs
Befunge JIT
-
py-rustitude
create and operate models for particle physics amplitude analyses
-
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
-
rustc_codegen_nvvm
A codegen backend for Rustc which targets the libnvvm CUDA library
-
luallaby
Work in progress A pure-Rust Lua interpreter/compiler
-
h2lang
H2 Language - A Herbert Online Judge compatible programming language with multi-agent support
-
rust-bf
A Brainfuck interpreter, generator, REPL, and IDE written in Rust
-
sap-interpreter
The interpreter crate for the SAP programming language
-
plexer
A Pattern-matching LEXER
-
eridani
Pure functional scripting, anywhere
-
yagbas_srcfiletypes
types for reading in yagbas source files
-
rtaichi
Rust language binding to the Taichi Runtime C-API
-
kind-span
Describes locations for the Kind compiler
-
typescript-types
Type definitions for TypeScript compiler
-
ssa-cc
Traits for compiling SSA IR to C
-
stella_checker
Rust-based, speedy Lua type checker
-
lisper
Lisp interpreter in Rust
-
codespan
Data structures for tracking locations in source code
-
greengold
A Forth bytecode interpreter library
-
sqry-lang-lua
Lua language plugin for sqry
-
leo-interpreter
Interpreter for the Leo programming language
-
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
-
makepad-live-tokenizer
Makepad platform live DSL tokenizer
-
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
-
portalis-cli
CLI for Portalis - GPU-accelerated Python to Rust/WASM transpiler
-
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
-
intarsia-build
Build helpers for compiling ISLE rulset files in build scripts for Intarsia optimizers
-
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
-
fervid_napi
Vue SFC compiler written in Rust
-
xlang_frontend
Frontend for XLang-Rust
-
hugr-model
Data model for Quantinuum's HUGR intermediate representation
-
llvm-in-rust-ir
Core LLVM-inspired intermediate representation data structures and builders for LLVM-in-Rust
-
graphix-stdlib
A dataflow language for UIs and network programming, standard library
-
lumen-vm
The AI-Native Programming Language
-
brainfrick
An optimizing brainfuck interpreter with helpful errors
-
lincoln
A low level programming language features linear types and direct manipulation of continuation (returning points)
-
intent-check
Semantic analyzer and type checker for IntentLang specifications
-
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
-
haloumi-picus
Haloumi backend to the Picus Constraint Language
-
steel-rc
Biased reference counting implementation for steel
-
tket2-hseries
TKET2 tool for preparing and validating
Hugrs for compilation targeting Quantinuum H-series quantum computers -
luaur-compile-cli
Command-line Luau source-to-bytecode compiler (Rust)
-
sylt-common
Common denominator for the Sylt programming language crates
-
qprime
An experimental programming language for quantum and weather calculations/applications
-
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
-
petr-vm
a basic VM for running and debugging petr IR
-
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
-
swamp-node
compiler node with documentation and meta information
-
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
-
pulley-interpreter
The Pulley interpreter, its bytecode definition, encoder, decoder, and etc
-
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
-
python-packaging
Python packaging primitives implemented in Rust
-
blink_core
Core interpreter for the Blink Lisp dialect
-
maat_prover
Zero knowledge STARK prover and verifier for the Maat programming language
-
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
-
impral
A command parsing and evaluation library for a LISP dialect, specialized for commandline input
-
prima-academy
Academic course classification primitives for Prima
-
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
-
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.
-
pfcl-typechecker
Hindley-Milner type inference for PFCL's content-addressed function catalog
-
oxc_minifier
A collection of JavaScript tools written in Rust
-
elworthy-diff
Symbolic differentiation for elworthy expression trees
-
forked_react_compiler_diagnostics
Rust port of the React Compiler, vendored from react/react
-
claw-ast
The Claw language Abstract Syntax Tree (AST)
-
flycatcher
programming language
-
flow_transpiler
Transpiler infrastructure for the Flow programming language
-
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
-
tket2
Quantinuum's TKET2 Quantum Compiler
-
caixa-fmt
Canonical formatter for tatara-lisp / caixa sources
-
wmlua-src
wmlua
-
rlisp
experimental lisp interpreter in rust
-
ojisan_fuck
Brain-fuck interpreter parsing emoji used by Japanese ojisans
-
evalexpr-jit
JIT compilation and symbolic differentiation of evalexpr expressions with Cranelift
-
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
-
rajac-token
Token definitions for the rajac Java frontend
-
llmcc-python
llmcc: llm context 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
-
inc
Incremental approach to compiler construction
-
tsz-scanner
TypeScript scanner/tokenizer for the tsz compiler
-
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
-
panproto-llvm
LLVM IR protocol definition and lowering morphisms for panproto
-
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
-
bicycle_compiler
A compiler for Pauli-based compilation (PBC) circuits to bicycle instructions
-
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
-
rslint_parser
An extremely fast ECMAScript parser made for the rslint project
-
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
-
rtlola2rust
A compiler from RTLola to Rust through StreamIR
-
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
-
typst-eval
Typst's code interpreter
-
cxx-llvm-build-common
Common build code for cxx-llvm and dependent crates
-
py-ir
Pin1Yin1 ir implementation
-
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 等）
-
sylt-typechecker
Typechecker for programs in the Sylt programming language
-
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
-
tenda-common
Common utilities for the Tenda programming language
-
otter-runtime
JavaScriptCore runtime for otter - TypeScript/JavaScript execution engine
-
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
-
kasl
Parses and translates the kasl code into KASL-IR, an intermediate representation for KASL
-
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
-
maat_stdlib
Standard library sources for the Maat programming language
-
typst-timing
Performance timing for Typst
-
sqry-lang-shell
Shell script language plugin for sqry
-
reic
A compiler that just works
-
blazefuck
A blazingly-fast (interactive) Brainfuck interpreter
-
leo-parser-lossless
Lossless syntax tree parser for the Leo programming language
-
js_parser
Javascript Parser : generate Aleph Syntax Tree
-
kind-target-kdl
KDL target for the kind compiler
-
bf
An optimizing Brainfuck interpeter and JIT compiler
-
claw-resolver
The Claw language name and type resolver
-
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
-
crisp-runtime
A small, expressive Lisp-inspired programming language
-
rl-cranelift
Cranelift-based JIT compiler backend for the rl-lang programming language
-
petr-utils
common utilities for the petr compiler and tooling
-
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
-
target-lexicon
LLVM target triple types
-
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
-
llvm-rs
A wrapper for LLVM, a powerful library and toolkit for compilers
-
kasm
The Kerbal Compiler Collection assembler for kOS
-
py-codegen-c
C codegen backend implementation for Pin1Yin1
-
seax_scheme
Scheme compiler for the Seax VM
-
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
-
alia-foundry
Cast web into native metal. HTML/CSS/JS compiled to GPU-rendered native binaries.
-
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
-
gluon_format
Code formatting for the gluon programming language
-
spade-hir-lowering
Helper crate for https://spade-lang.org/
-
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
-
ezno
A fast and correct TypeScript type checker and compiler with additional experiments. For use as a library or through the CLI
-
jzero-symtab
Symbol table types for the Jzero compiler
-
masl_formatter
Maduka Authorization Specification Language (MASL) toolchain and runtime
-
baracuda-nvrtc-sys
Raw FFI bindings and dynamic loader for NVIDIA NVRTC (runtime CUDA-C++ to PTX compiler)
-
n-rustc-codegen-cranelift-pre-t-x64-win-msvc-p1
Segment rustc-codegen-cranelift-preview.target.x86_64-pc-windows-msvc part p1
-
graphcal-plugin-abi
Type-safe, unit-aware, Git-friendly reactive programming language for engineering calculations
-
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
-
lolli-prove
Proof search for the Lolli linear logic workbench
-
silt-lua
A pure rust Lua interpreter and virtual machine
-
moonlift
A pure-rust implementation of Lua (5.4) with just-in-time (JIT) compilation using
cranelift -
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
-
metaltile-core
Core IR types and data structures for the MetalTile GPU kernel DSL
-
carbon-assembler
An assembler for the carbon CPU
-
mech-time
Time library for the Mech language
-
op8d_lexemizer
Opinionated library for transforming code to a vector of Lexemes
-
brainease_transpiler
A brainf*ck-style programming language, but readable
-
synth-cli
CLI for Synth, the WebAssembly-to-ARM Cortex-M AOT compiler
-
citadel-middleend
The middleend/optimizer for the citadel compiler backend
-
luah
Unofficial lua impl by HydroRoll-Team
-
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
-
xlang_vm_core
XLangVM for XLang-Rust
-
stak-native
Optimized primitives of native functions for Stak Scheme
-
tl-data
Data engine for ThinkingLanguage — DataFusion, connectors, I/O
-
seax
SECD virtual machine for interpreting programs in FP languages and a Scheme compiler targeting that machine
-
llvm-in-rust-target-x86
x86-64 target backend for LLVM-in-Rust code generation
-
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
-
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
-
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.
-
c-lang
Scripting language made in rust
-
crain
A Brainfuck compiler/interpreter/tool
-
diatom-cli
The diatom programming language
-
refrain-core
Differential Refrain Engine core: DSL parser and AST
-
ano_jit_bfi_rs
Outdated Just-In-Time BrainFuck Interpreter written in RuSt
-
csw-core
Core categorical structures for the Categorical Semantics Workbench - define categories and derive type systems
-
tsz-emitter
TypeScript-to-JavaScript emitter and transforms for the tsz compiler
-
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
-
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
-
eirproject/libeir_intern
Erlang ecosystem common IR
-
comet-rs
Rust eDSL for COMET: domain specific COMpiler for Extreme Targets
-
cas-vm
Virtual machine that executes CalcScript bytecode
-
suffete
A standalone PHP type system: representation, comparison, and type checking primitives for static analysis tools
-
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)
-
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
-
tinywasm
A tiny WebAssembly interpreter
-
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
-
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
-
petr-pkg
package management for the petr language
-
kodept-interpret
compiler with dependent types support in mind
-
hugr-persistent
Persistent IR structure for Quantinuum's HUGR
-
moore-svlog-hir
The HIR of the SystemVerilog implementation of the moore compiler framework
-
weavy
Shared lowered-program substrate for interpreters and copy-and-patch backends
-
nextjs_react_compiler_optimization
Rust port of the React Compiler, vendored from facebook/react
-
bf-compile
A compiler for BrainFuck
-
cyclang-parser
Cyclang is a toy language built in LLVM
-
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
-
ruau-runner
Bounded multi-tenant request runner for Ruau
-
blink_runtime
Runtime lib for creating plugins for blink
-
karnc
The Karn compiler — a typed function-then-context DSL that compiles to TypeScript
-
lunir
A universal intermediate representation oriented towards Lua
-
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
-
math-jit
Compile arithmetic expressions to native code
-
tenda-prelude
Prelude for the Tenda programming language
-
graphcal-lsp
Language Server Protocol implementation for Graphcal
-
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
-
irvm-lower
The lowering library for IRVM to go to LLVM IR
-
bop-cli
CLI and REPL for the Bop programming language
-
autoken-rustc
A rust-lang static analysis tool to automatically check for runtime borrow violations
-
masl_lsp
Maduka Authorization Specification Language (MASL) toolchain and runtime
-
tur
Turing Machine Language - Parser, interpreter, and execution engine
-
enalang_optimizer
Exhaustingly Notorious Algorithms - optimizer
-
bsharp_lsp
The B# programming language!
-
calyx-backend
Compiler Infrastructure for Hardware Accelerator Generation
-
bicycle_common
Common definitions for bicycle architecture compiler crates
-
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
-
tree-sitter-java
Java grammar for tree-sitter
-
tl-ai
AI/ML integration for ThinkingLanguage — tensors, training, inference, LLM
-
exers
compiling and running other code in sandboxed environment
-
rajac-classpath
Classpath loading and symbol extraction for rajac
-
husk-types
Type definitions for the Husk programming language
-
boolfuck
unoptimized boolfuck interpreter which can convert brainfuck code
-
luajit2-sys
LuaJIT-2.1 FFI Bindings
-
kind-query
Query module for the kind compiler
-
genotype_lang_rs_core
Genotype language Rust target core crate
-
julia
Idiomatic and safe Julia bindings for Rust
-
noxue-compiler
利用docker实现在线编译运行代码
-
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
-
easter
Type definitions for ECMAScript abstract syntax trees
-
mech-system
System library for the Mech language
-
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
-
symjit
a lightweight just-in-time (JIT) optimizer compiler
-
decy-codegen
Rust code generation from HIR with minimal unsafe blocks
-
enalang_macro
Exhaustingly Notorious Algorithms - macro support
-
ruby
Pure Rust implementation of Ruby runtime environment
-
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
-
maat_air
CPU constraint system (AIR) for the Maat programming language
-
arithmetic-eval
interpreter for arithmetic expressions
-
gluon_repl
REPL for gluon. A static, type inferred programming language for application embedding
-
cfla-cli
Command-line interface for the compact functional low-level assembler, cfla, a declarative functional systems programming language
-
synth-verify
SMT translation validation for the Synth compiler (ordeal QF_BV engine; optional Z3 differential oracle)
-
pk_parser
The Palacinke lang parser
-
maat_lexer
DFA-based lexer for the Maat programming language
-
llvm-pm-sys
Raw FFI bindings for LLVM new PassManager C++ stubs
-
tsz-checker
TypeScript type checker for the tsz compiler
-
llts_frontend
LLTS frontend — oxc parser and semantic analysis wrappers
-
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
-
llts_driver
LLTS driver — pipeline orchestration from TypeScript to native
-
voce-adapter-static
Voce IR static deployment adapter — plain dist/ folder output
-
bynk-lsp
bynkc-lsp — the Language Server for the Bynk DSL
-
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!
-
gluon_check
The typechecker for the gluon programming language
-
liblox
VM of the lox language
-
enalang_repl
Exhaustingly Notorious Algorithms - repl
-
eadup
A native-first markup language and EADUP compiler for automated, standards-compliant document typesetting
-
lolli-codegen
Code generation for the Lolli linear logic workbench
-
darklua-demo
Transform Lua scripts
-
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
-
haskelujah-span
Source offsets, file IDs, byte-offset spans, and span arithmetic for the Haskelujah compiler
-
inline-python
Inline Python code directly in your Rust code
-
elworthy-codegen
Cranelift lowering of elworthy expression trees
-
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
-
forked_react_compiler_ssa
Rust port of the React Compiler, vendored from react/react
-
swc_ecma_react_compiler
SWC helpers for the React 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
-
genotype_runtime
Genotype runtime
-
haloumi-core
Core types and traits of the Halo2 frontend for LLZK
-
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
-
sljit-sys
System crate for sljit using bindgen and ast-grep
-
rustpython-bytecode
RustPython specific bytecode
-
lia-plugin
Compiler plugin for writing Lia code as a macro
-
symboscript-interpreter
SymboScript interpreter
-
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
-
bicycle_benchmark
Generates PBC circuits that can be used for benchmarking
-
draxl-lower-rust
Lower validated Draxl Rust-profile files to ordinary Rust
-
gluon_doc
The documentation generator for the gluon programming language
-
masl_linter
Maduka Authorization Specification Language (MASL) toolchain and runtime
-
tinymist-task
Task model of typst for tinymist
-
rong_path
Path module for RongJS
-
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
-
swc_es_codegen
High-performance code generator for swc_es_ast
-
haloumi-llzk
Haloumi backend to LLZK
-
portalis-transpiler
Python to Rust transpiler engine with WASM compilation support
-
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-in-rust-transforms
Optimization and transformation passes for LLVM-in-Rust IR
-
llvm-sys-featured
Bindings to LLVM's C API
-
cranelift-simplejit
JIT library backed by Cranelift
-
terl
a general parser
-
treeedb-python
Generate Datalog facts from Python source code
-
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
-
tsz-lowering
AST-to-type lowering bridge for tsz
-
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
-
wasmer-clif-fork-simplejit
JIT library backed by Cranelift
-
vicis
Manipulate LLVM-IR in Pure Rust
-
kz80_bc
Arbitrary-precision decimal arithmetic language and calculator for Z80
-
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
-
dsp56300
assembler, disassembler, and JIT emulator
-
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
-
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
-
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
-
vyre-foundation
Foundation layer: IR, type system, memory model, wire format. Zero application semantics. Part of the vyre GPU compiler.
-
norn
High-level compiler library
-
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
-
leo-span
Span handling for the Leo programming language
-
josie-core
High-performance core runtime for JOSIE (JSON Omni Safe Interactive Expressions), with deterministic tree-based pipeline execution and embeddable operator/function registries
-
nexus-lang-cli
Command-line interface and REPL for the Nexus network description language
-
mir-sys
FFI bindings to MIR Project (https://github.com/vnmakarov/mir)
-
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
-
oxc_mangler
A collection of JavaScript tools written in Rust
-
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
-
airl-interp
Tree-walking interpreter for AIRL IR with 74 builtins
-
vexity
Tiny scripting language for hacking on abstractions of financial markets
-
ts-runtime-typechecker
A command line tool that generates ts/js typechecker functions from typescript types
-
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
-
cyclang-backend
Cyclang is a toy language built in LLVM
-
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
-
brink-fmt
Source code formatter for inkle's ink narrative scripting language
-
llvm-in-rust-analysis
Control-flow, call-graph, dominance, loop, and use-def analyses for LLVM-in-Rust IR
-
synth-core
Core types, error handling, and backend trait for the Synth compiler
-
vyre-lints
Lego-block enforcement lints for vyre. Forbids raw IR construction in dialect crates.
-
tsz-lsp
Language Server Protocol implementation for the tsz compiler
-
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
-
qwik-core
Qwik optimizer compiler
-
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
-
vm_lang
interpreted language written in Rust
-
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!
-
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
-
libjit-sys
Just-In-Time Compilation in Rust using LibJIT bindings
-
mogi_cpu
CPU emulation core for MOGI
-
tinymist-l10n
Localization support for tinymist and typst
-
maat_runtime
Runtime value system for the Maat programming language
-
voce-adapter-netlify
Voce IR Netlify deployment adapter
-
tree-sitter-python
Python grammar for tree-sitter
-
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
-
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
-
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
-
waspy
A Python interpreter written in Rust, designed for WebAssembly
-
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
-
quickjs-rusty
QuickJS (QuickJS-NG) Javascript engine wrapper, and more
-
maat_codegen
Bytecode code generation for the Maat programming language
-
bock-build
Build pipeline for Bock projects, coordinating parse, check, codegen, and target compilation
-
hugr-core
Quantinuum's Hierarchical Unified Graph Representation
-
assura-macros
Proc macros for inline Assura contract annotations in Rust
-
w16-core
Ядро W16
-
decy-stdlib
C standard library prototypes for the Decy C-to-Rust transpiler
-
tsz-solver
TypeScript type solver for the tsz compiler
-
synth-backend-aarch64
AArch64 (A64) host-native backend for synth — integer subset (milestone 1, #538)
-
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
-
maat_types
Hindley-Milner type inference engine for the Maat programming language
-
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
-
lolli-extract
Term extraction for the Lolli linear logic workbench
-
molt-shell
Molt Application Frameworks
-
metaltile-runtime
Apple Metal runtime dispatch for MetalTile GPU kernels
-
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;…
-
bock-vocab
Self-describing language vocabulary emitter for Bock — keywords, errors, prelude, stdlib, annotations
-
llvm-in-rust-ir-parser
Lexer and parser for LLVM textual IR into LLVM-in-Rust data structures
-
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)
-
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
-
maat_module
Module system and multi-file compilation for the Maat programming language
-
dynasm-lib
A pure rust assembler, not a JIT. Used within direct-asm for maximum control over assembly.
-
metaltile-macros
Proc-macro crate providing the #[kernel] DSL for MetalTile GPU kernels
-
spade-types
Helper crate for https://spade-lang.org/
-
cranelift-module
Support for linking functions and data with Cranelift
-
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
-
genotype_lang_rs_converter
Genotype language Rust target converter crate
-
jit_macros
JIT Macros
-
brink-codegen-inkb
Bytecode codegen backend: LIR → StoryData (inkb format)
-
litto
Building blocks for DSL scripting language interpreters that interact with native Rust code
-
tabulon_macros
Internal procedural macros for the tabulon expression engine
-
stak-configuration
Stak Scheme configuration
-
synth-opt
Peephole optimization passes for the Synth compiler
-
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
-
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
-
graphcal-plugin-macros
Type-safe, unit-aware, Git-friendly reactive programming language for engineering calculations
-
llvm-in-rust-bitcode
Compact bitcode reader and writer for LLVM-in-Rust IR modules
-
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
-
brink-converter
Converts inklecate .ink.json to brink .inkb format
-
maat_eval
Tree-walking interpreter and macro expansion engine for the Maat programming language
-
beadie-core
Bead chain, broker, hotness policy, swap, and deopt — no JIT backend
-
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
-
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
-
bock-core
Core stdlib registry and runtime primitives for the Bock language
-
cranelift
Umbrella for commonly-used cranelift crates
-
diaglite
Span + Diag diagnostics kernel for purpose-sized languages: byte spans, line/col, caret snippets that never panic on mid-char offsets
-
oak-asciidoc
High-performance incremental AsciiDoc parser for the oak ecosystem
-
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
-
autophagy
AOT compiler for Rust