-
ariadne
A fancy diagnostics & reporting crate
-
tree-sitter
Rust bindings to the Tree-sitter parsing library
-
rustc-demangle
Rust compiler symbol demangling
-
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.
-
annotate-snippets
Format diagnostic reports, including highlighting snippets of text
-
cel
A parser and interpreter for the Common Expression Language (CEL)
-
ena
Union-find, congruence closure, and other unification code. Based on code from rustc.
-
oxc
A collection of JavaScript tools written in Rust
-
oxc_span
A collection of JavaScript tools written in Rust
-
oxc_ast_visit
A collection of JavaScript tools written in Rust
-
apollo-compiler
A compiler for the GraphQL query language
-
llvm-sys
Bindings to LLVM's C API
-
clang
A somewhat idiomatic Rust wrapper for libclang
-
apollo-parser
Spec-compliant GraphQL parser
-
melior
The rustic MLIR bindings in Rust
-
jaq-interpret
Interpreter for the jaq language
-
brillig
bytecode ACIR uses for non-determinism
-
boa_string
Boa is a Javascript lexer, parser and compiler written in Rust. Currently, it has support for some of the language.
-
vox-lang
A systems level compiler for Vox (sentence based code)
-
tree-sitter-language-pack
Core library for tree-sitter language pack - provides compiled parsers for 371 languages
-
cranelift-frontend
Cranelift IR builder helper
-
c2rust
C to Rust translation, refactoring, and cross-checking
-
oxc_parser
A collection of JavaScript tools written in Rust
-
boa_parser
ECMAScript parser for the Boa JavaScript engine
-
gluon
A static, type inferred programming language for application embedding
-
mago-docblock
Analyzes PHP docblocks to extract annotations, tags, and documentation comments, aiding tools that rely on inline documentation
-
monty
A secure, snapshotable Python sandbox written in Rust
-
rustpython-compiler
A usability wrapper around rustpython-parser and rustpython-compiler-core
-
hstr
A string type which is optimized for hash operations
-
rolldown-ariadne
A fork of github.com/zesterer/ariadne
-
typst-assets
Assets for the Typst compiler
-
oxc_transformer
A collection of JavaScript tools written in Rust
-
wdl-ast
An abstract syntax tree for Workflow Description Language (WDL) documents
-
fucker
BrainFuck interpreter and optimizing JIT compiler
-
oxc_diagnostics
A collection of JavaScript tools written in Rust
-
gccjit
Higher-level Rust bindings for libgccjit
-
mago-type-syntax
core utilities useful for building lexers and parsers within Mago
-
starlark
language in Rust
-
rustpython-ast
AST definitions for RustPython
-
typst-pdf
PDF exporter for Typst
-
steel-core
Core compiler and VM implementation for steel
-
ascent
Logic programming in Rust
-
miden-project
Interface for working with Miden projects
-
sus_compiler
Compiler for the SUS Hardware Design Language
-
oxc_data_structures
A collection of JavaScript tools written in Rust
-
oxc_ast
A collection of JavaScript tools written in Rust
-
cranelift-native
Support for targeting the host with Cranelift
-
rustlr
Bottom-Up Parser Generator with Advanced Options
-
rune
Language, an embeddable dynamic programming language for Rust
-
rustc-std-workspace-core
integration of crates.io crates into rust-lang/rust standard library workspace
-
dynasmrt
runtime for assembling code at runtime. Combined with the plugin crate dynasm it can be used to write JIT compilers easily.
-
spirt
Shader-focused IR to target, transform and translate from
-
acir_field
The field implementation being used by ACIR
-
rilua
Lua 5.1.1 implemented in Rust, targeting the World of Warcraft addon variant
-
oxc_allocator
A collection of JavaScript tools written in Rust
-
brink-lsp
Language server for inkle's ink narrative scripting language
-
typespec_client_core
Client runtime for TypeSpec-generated libraries
-
cranelift-jit
A JIT library backed by Cranelift
-
stickle
TUI for a streamlined Rusty PLC Compiler workflow
-
spirv-cross2
Safe Rust bindings to SPIRV-Cross
-
pliron
Programming Languages Intermediate RepresentatiON
-
python-rs
A stackless Python 3 interpreter written in Rust — academic/hobby AI-assisted port of CPython. Pre-release; not usable yet.
-
oxc_codegen
A collection of JavaScript tools written in Rust
-
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
-
lex-types
Type system + effect inference for Lex
-
tinymist-package
Tinymist package support for Typst
-
ruchy
A systems scripting language that transpiles to idiomatic Rust with extreme quality engineering
-
diplomat-runtime
Common runtime utilities used by diplomat codegen
-
typst-render
Raster image exporter for Typst
-
oxc_semantic
A collection of JavaScript tools written in Rust
-
phon-jit
phon's optional copy-and-patch JIT: lowers the IR to machine code via rustc/LLVM stencils
-
diplomat
FFI generation macro
-
decy-hir
High-level Intermediate Representation for C-to-Rust transpilation
-
gust-cli
The Gust compiler CLI — compile .gu state machine files to Rust, Go, WASM, no_std, or C FFI
-
monkey-gc
QuickJS-style GC runtime for Monkey (bytecode VM with cycle collector)
-
brink-cli
CLI for compiling and running ink stories
-
frg
Compiled programming language for frogs!
-
obeli-sk-boa-ast
Abstract Syntax Tree definition for the Boa JavaScript engine
-
typst-layout
Typst's layout engine
-
harn-parser
Parser, AST, and type checker for the Harn programming language
-
decy-parser
C AST parsing using clang-sys for Decy transpiler
-
hermes-sema
port of the Hermes semantic analysis (scope resolution and validation) pass by Tzvetan Mikov, the architect of Hermes. Not an official Meta project.
-
codesnake
Pretty printer for non-overlapping code spans
-
oxc_minifier
A collection of JavaScript tools written in Rust
-
rustc-build-sysroot
Build a rustc sysroot with custom flags
-
chap
easy to learn, interpretive, scripting language written in Rust
-
vrl
Vector Remap Language
-
luna-core
Pure-Rust Lua runtime (interpreter only, zero third-party dependencies). The JIT-equipped variant lives in the
luna-jitcrate. -
ironwork
COBOL: the compiler driver
-
luaur-code-gen
Native (A64/X64) code generation for Luau (Rust)
-
glslang
Rust bindings to glslang
-
ternlang-mcp
MCP server for ternlang — connects any AI agent to balanced ternary decision logic via trit_decide and friends
-
fusevm
Language-agnostic bytecode VM with fused superinstructions and a 3-tier Cranelift JIT (linear/block/tracing)
-
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-engine
Boa is a Javascript lexer, parser and compiler written in Rust. Currently, it has support for some of the language.
-
rucc-target
Target descriptions, register files and ABI data for the rucc C compiler
-
dylint-link
A wrapper around Rust's default linker to help create Dylint libraries
-
unpopped
vendor-neutral kernel generator: the backend-agnostic IR, plan, transform pipeline, contracts and dispatch artifacts, plus the
BackendandCompilertraits a target implements. Ships… -
monkey-asm
AOT AArch64 assembly backend for monkeylang (Linux ELF and macOS Mach-O)
-
jsonpiler
a Json syntax programming language for Windows
-
paxc
A compiler for the pax DSL, producing Power Automate cloud flow definitions
-
typst-svg
SVG exporter for Typst
-
pen-ffi
FFI library for Pen programming language
-
keleusma
Total Functional Stream Processor with definitive WCET and WCMU verification, targeting no_std + alloc embedded scripting
-
runmat-hir
High-level IR for RunMat with type inference and lowering utilities
-
compiler
A tiny TypeScript-subset compiler that emits native binaries via assembly + cc
-
logicaffeine-compile
The LOGOS compiler: type checking, the optimizer, the interpreter and bytecode VM, and the Rust, C, WASM, RISC-V, CUDA and hardware backends
-
xlsynth
Accelerated Hardware Synthesis (XLS/XLSynth) via Rust
-
tsrs_compiler
TypeScript compiler programs and emit for tsrs
-
runmat-parser
Parser for RunMat (MATLAB/Octave) producing HIR from token streams
-
obeli-sk-boa-string
Boa is a Javascript lexer, parser and compiler written in Rust. Currently, it has support for some of the language.
-
haskelujah
A Haskell compiler in Rust — GHC-compatible, self-contained, faster than GHC
-
rosy-cli
Rosy CLI: transpile and run Rosy programs
-
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
-
rustc_version_runtime
querying the version of the rustc compiler used in runtime
-
tket
Quantinuum's TKET Quantum Compiler
-
midenc-log
flexible trace logging for midenc
-
typst-html
Typst's HTML exporter
-
cranelift-codegen
Low-level code generator library
-
cudaforge
Advanced CUDA kernel builder for Rust with incremental builds, auto-detection, and external dependency support
-
tdsl-core
Core IR and lowering logic for the Timeline DSL compiler
-
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
-
crisp-parser
Crisp parser — tokens to AST (spec Appendix A)
-
typst-cli
The command line interface for Typst
-
runmat-gc
Generational garbage collector for RunMat with optional pointer compression
-
luna-jit-llvm
LLVM 18 + inkwell 0.10 alternative JIT backend for the goliajp/luna Lua runtime. Lives alongside
luna-jit(Cranelift); backend selection at runtime via theLUNA_JIT_BACKEND=llvmenv var… -
maslc
Maduka Authorization Specification Language (MASL) toolchain and runtime
-
runmat-mir
Mid-level IR and analysis scaffolding for RunMat
-
tsrs_lsproto
TypeScript language server protocol types for tsrs
-
tishlang_builtins
Shared builtin implementations for Tish (array, string, object, math)
-
somni-expr
An expression evaluation library
-
cxxbridge-flags
Compiler configuration of the
cxxcrate (implementation detail) -
tsrs_checker
TypeScript type checker for tsrs
-
tket-qsystem
TKET tool for preparing and validating
Hugrs for compilation targeting Quantinuum H-series quantum computers -
cranelift-object
Emit Cranelift output to native object files with
object -
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
-
crisp-lexer
Crisp lexer — UTF-8 tokenization (spec §2)
-
xdy
Complex RPG dice expression evaluator with probability distribution support
-
atlas_77
Wannabe systems programming language
-
uiua
A stack-based array programming language
-
firmion
Ergonomic firmware and binary file creation tool
-
run
a.k.a. runtool: the bridge between human and AI tooling
-
ternlang-core
Compiler and VM for Ternlang — balanced ternary language with affirm/tend/reject trit semantics, @sparseskip codegen, and BET bytecode execution
-
rumoca
Modelica compiler written in RUST
-
bashrs
Rust-to-Shell transpiler for deterministic bootstrap scripts
-
typeset
A DSL for defining source code pretty printers
-
obeli-sk-boa-parser
ECMAScript parser for the Boa JavaScript engine
-
hugr
Quantinuum's Hierarchical Unified Graph Representation
-
ternlang-lsp
LSP 3.17 language server for ternlang — hover docs, code completion, and live diagnostics for .tern files
-
onion-lang
A modern functional programming language with asynchronous execution and lazy evaluation
-
nagami
Shrinks WGSL shaders via Naga IR optimization passes
-
pfcl-lsp
PFCL language server — diagnostics, catalog completion, and hover over the standard load pipeline
-
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.
-
cljrs-ir
Intermediate representation types for clojurust compiler and interpreter
-
python-ast
compiling Python to Rust
-
oxc_traverse
A collection of JavaScript tools written in Rust
-
lex-syntax
Tokenizer + parser for the Lex programming language
-
lex-bytecode
Bytecode compiler + VM for Lex
-
probatum
Write the contract, get the proof: compile behavioral intent into programs with machine-checkable proof certificates
-
hvm
A massively parallel, optimal functional runtime in Rust
-
miden-package-registry
Package registry interfaces and dependency resolution for Miden packages
-
seq-compiler
Compiler for the Seq programming language
-
forked_react_compiler
Rust port of the React Compiler, vendored from react/react
-
dusk-lang
Compiler for the dusk programming language, a systems language with generational memory safety, emitting textual LLVM IR
-
tket-json-rs
Serializable definition of TKET circuits and operations
-
bf-cli
Command-line Brainfuck compiler and runner for the bf-lab toolchain
-
erg
programming language
-
cyber-nox
proof-native virtual machine over the Goldilocks field
-
logicaffeine-language
The LOGOS front end: English sentences to first-order logic, and the parser for LOGOS programs and LGX pages
-
sqry-lang-python
python language plugin for sqry
-
wadl
parser for Rust
-
depyler-annotations
Annotation parsing and processing for Depyler
-
viperjs
An embeddable JavaScript engine in safe Rust, with zero runtime dependencies
-
brink-environment
The reified, content-addressed compilation Environment value plus the effectful Project/SourceTree producer (#1306)
-
relon-analyzer
Semantic analysis layer for the Relon language: name resolution, schema desugar, diagnostics
-
big-code-analysis
compute and export code metrics
-
lift-quantum
LIFT compiler quantum dialect: qubits (linear types), quantum gates, noise attributes, layout mapping
-
sqry-lang-kotlin
Kotlin language plugin for sqry
-
symjit
a lightweight just-in-time (JIT) optimizer compiler
-
parsit
very simple lib, the parsing combinators, recursive descendent that uses logos as lexer
-
ps-boa-ast
Abstract Syntax Tree definition for the Boa JavaScript engine
-
decy-analyzer
Static analysis and type inference for C code
-
groovy
as a fusevm frontend: lexer, parser, and compiler to fusevm::Chunk, run on the shared three-tier Cranelift JIT — no bespoke VM or JVM
-
brink-ide
Protocol-agnostic IDE query library for inkle's ink
-
rustpython
A python interpreter written in rust
-
packtab
Pack static integer tables into compact multi-level lookup tables
-
ps-boa-string
Boa is a Javascript lexer, parser and compiler written in Rust. Currently, it has support for some of the language.
-
tinywasm
A tiny WebAssembly interpreter
-
delo
A statically typed, compiled-to-C programming language that can time-travel
-
rspack_plugin_rsc
Rspack React Server Component plugin
-
pandora-interpreter
A command-line tool to run pandora language
-
decy
CLI tool for C-to-Rust transpilation with EXTREME quality standards
-
steel-parser
Parser for use within steel
-
brink-format
Binary interface between brink compiler and runtime
-
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.
-
r2u2_cli
R2U2 CLI: A stream-based runtime monitor command-line interface
-
frazaro
The command-line door to frazaro-core
-
bock-air
Annotated Intermediate Representation (AIR) for the Bock compiler — typed, scope-resolved, effect-aware
-
kora-syntax
Lexer, parser, and AST for the Kora language
-
pluto-lang
A interpreted programming language made in Rust
-
kz80_lisp
A minimal LISP interpreter and compiler for RetroShield Z80
-
fsqlite-planner
Query planner: name resolution, WHERE analysis, join ordering
-
sqry-lang-java
Java language plugin for sqry
-
seq-core
Core runtime library for stack-based languages (Value, Stack, Channels)
-
lamina
High-performance compiler backend for Lamina Intermediate Representation
-
luna-aot
Ahead-of-time compiler from Lua source to a self-contained native binary, built on luna-core's VM: the program is embedded as luna bytecode and the hot traces of a warmup run are compiled to machine code…
-
sema-lang
Sema — a Lisp dialect with first-class LLM primitives
-
fable
Tiny typed language over Facet-reflected Rust values, lowered toward Weavy IR
-
typst-utils
Typst
-
lumen-lang
Lumen — a dynamic, bytecode-compiled programming language with a bytecode VM, generational GC, and a full toolchain
-
tabnas-bnf
Shared compiler for BNF-family grammar front-ends on the tabnas parser: grammar IR in, tabnas GrammarSpec out
-
jstime
JS Runtime
-
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
-
zust-dynamic
Dynamic value model for Zust scripts, with JSON, MessagePack, bytes, and typed vectors
-
haskelujah-driver
Compilation driver and project orchestration for the Haskelujah compiler
-
encore-toolchain
Compiler and bytecode VM for Fleche, a functional language with first-class continuations
-
nexus-lang
A programming language for generating component network descriptions
-
tishlang_ui
Shared JSX lowering and UI runtime (vnode, hooks, host protocol) for Tish
-
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
-
stak-r7rs
Stak Scheme primitives for R7RS
-
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… -
typst-syntax
Parser and syntax tree for Typst
-
forgellm-frontend
Model parsing (GGUF, SafeTensors) and IR construction for ForgeLLM
-
stak-vm
Virtual machines for Stak Scheme
-
oxc_syntax
A collection of JavaScript tools written in Rust
-
crisp-diagnostics
Crisp-level diagnostics and CIR→Crisp span mapping (spec §17.2–17.4)
-
junocc
Compiler for JunoLang
-
gabelang
A high level, interpretted and garbage collected programming language
-
junolsp
Language Server for JunoLang
-
grift
A tiny Kernel-style Lisp built on fexprs, for embedding in Rust
-
rucc-base
Arenas, interning, index newtypes and shared data structures for the rucc C compiler
-
tinymist
An integrated language service for Typst
-
edlc_lsp
EDLc Language Sever Protocol implementation
-
cellang
Interpreter for the CEL expression language
-
ternlang-runtime
Distributed actor runtime for ternlang — TCP-based TernNode with remote spawn/send/await over newline-JSON protocol
-
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
-
tl-parser
Recursive descent parser for ThinkingLanguage
-
chalk-ir
Chalk's internal representation of types, goals, and clauses
-
lex-store
Content-addressed on-disk store for Lex stages, branches, and traces
-
tsrs_vfs
Virtual filesystem and bundled TypeScript libraries for tsrs
-
crisp-ast
Crisp abstract syntax tree and source spans
-
zetac
The final systems language
-
ingot-semantic
Name resolution, type checking and effect/policy analysis for Ingot
-
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
-
rucc-asm
Instruction encoders, the integrated assembler, inline assembly and relaxation
-
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
-
sora-core
powerful configuration table compiler for games and data-heavy tools
-
kora-types
Name resolution and editor-facing checks for the Kora language
-
ps-boa-parser
ECMAScript parser for the Boa JavaScript engine
-
mimium-lang
mimium(minimal-musical-medium) an infrastructural programming language for sound and music
-
sqry-lang-php
PHP language plugin for sqry
-
axonyx-core
Core parser, lowering, query model, and SQL draft compiler for Axonyx
-
stak-build
Build scripts for Stak Scheme
-
garnish_lang_compiler
Utilites to compile garnish scripts
-
gluon_repl
REPL for gluon. A static, type inferred programming language for application embedding
-
serpentine
Powerful simplistic workflow runner
-
alephc
Aleph Compiler (or transpiler)
-
stak-file
File system for Stak Scheme
-
vyre
GPU compute intermediate representation with a standard operation library
-
stak-device
Devices for Stak Scheme
-
draxl-ast
Typed AST and metadata model for Draxl
-
teacat
A modern document languge for web pages
-
assura-parser
Lexer, parser, and AST for the Assura contract language
-
semantic-analyzer
Semantic analyzer library for compilers written in Rust for semantic analysis of programming languages AST
-
blue-lang-syntax
blue's surface syntax: lexer, parser, and lowering to the tatara-lisp quoted form
-
zuqe
Rust-native JavaScript engine for embedding: stackless interpreter, host-enforced memory and stack limits, interrupt control, and a Promise/Future bridge. For scripting, plugin runtimes…
-
ternlang-codegen
C transpiler backend for the Ternlang compiler — emits C source from the Ternlang AST for native cross-compilation targets
-
logicaffeine-data
LOGOS runtime values, collections, wire format and CRDTs, shared by native and WASM builds
-
zust-parser
Lexer and parser for the Zust scripting language
-
ingot-parser
Recursive-descent parser with error recovery for the Ingot agent language
-
stak-process-context
Process context for Stak Scheme
-
tsrs_modulespecifiers
TypeScript module specifier generation for tsrs
-
rasm-core
Core of RASM x86_64 assembler
-
sqry-lang-c
C language plugin for sqry
-
bynk-check
The semantic-analysis layer of the Bynk compiler: name resolution, type checking, the kernel and builtin registries, first-party sources, and the analysis tables the IDE queries
-
stak-time
Time library for Stak Scheme
-
stak-native
Optimized primitives of native functions for Stak Scheme
-
syn-locator
A source mapper for syn syntax trees
-
tsrs_transformers
TypeScript and JavaScript transforms for tsrs
-
typst-realize
Typst's realization subsystem
-
depyler
A Python-to-Rust transpiler focusing on energy-efficient, safe code generation with progressive verification
-
forgellm-codegen-metal
Metal GPU code generation for Apple Silicon inference in ForgeLLM
-
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
-
stak-engine
Stak Scheme scripting engine for Rust
-
haskelujah-naming
Name resolution, interfaces, and symbol environments for the Haskelujah compiler
-
tsrs_lsp
TypeScript language server for tsrs
-
pipeline-script
Script engine designed for the project construction tool pipeline(crate name pipeline-cli)
-
vortex-jit
bindings for the VORTEX JIT compiler — multi-tier JIT with AOT background compilation, trace-based PGO with re-tracing, retargetable regalloc (x86-64/ARM64/RISC-V), float arithmetic…
-
bvm-lang
The LSB bytecode VM: executes bytecode-lang modules with typed and dynamic values, PHP-style ordered maps, exceptions, stackful coroutines, a tracing GC, fuel, and memory budgets
-
qala-compiler
Compiler and bytecode VM for the Qala programming language
-
leo-abi
ABI generation for Leo programs
-
vexilc
The Vexil schema compiler CLI
-
masl_bytecode
Maduka Authorization Specification Language (MASL) toolchain and runtime
-
zapcode-core
A minimal, secure TypeScript subset interpreter — parse, compile, execute, snapshot
-
rajac
Command-line interface for the rajac Java compiler
-
rspack_plugin_rsdoctor
rspack rsdoctor native plugin
-
depyler-analyzer
Static analysis and optimization engine for Depyler
-
ternlang-test
Test harness and assertion utilities for ternlang programs — BET-VM test runner, trit assertions, and golden-file diffing
-
struo-synth
Synthesis passes and pipeline for Struo
-
loopkit
The Loop Language compiler — validates skill repositories against the Loop Language spec
-
nl-compiler
Verilog frontend compilation into a memory-safe netlist IR
-
tabnas-c
C23 concrete-syntax-tree grammar plugin for the tabnas parsing engine, over the jsonic base grammar and the expr operator plugin
-
leo-disassembler
A disassembler for the Leo programming language
-
harn-clock
Unified time + sleep abstraction for the Harn runtime, CLI, triggers, cron, and harn-cloud
-
soppo
Compiler for Soppo, a Go superset with enums, pattern matching, and nil safety
-
midenup
The Miden toolchain manager
-
tidepool-repr
Intermediate representation for the Tidepool compiler
-
quickjs_runtime
Wrapper API and utils for the QuickJS JavaScript engine with support for Promise, Modules, Async/await
-
kataan
A high-performance JavaScript engine written in pure Rust. Library, C FFI, and CLI.
-
chalk-recursive
Recursive solver for the Chalk project
-
airlang
Air is a universal, reliable, and lean programming language
-
rlang
R as a fusevm frontend: a lexer, parser, and compiler to fusevm bytecode on an RHost vector heap, with no bespoke VM or JIT
-
hsml
A pug-inspired HTML preprocessor
-
stak-sac
Stand-Alone Complex for Stak Scheme
-
rnsc
RNS assembler/compiler CLI for the Lagertha VM project
-
ps-boa-engine
Boa is a Javascript lexer, parser and compiler written in Rust. Currently, it has support for some of the language.
-
tl-ir
Intermediate Representation for ThinkingLanguage table pipe optimization
-
haskelujah-parser
Lexer, layout, and parser pipeline for the Haskelujah compiler
-
zust-compiler
Compiler front-end and semantic lowering for the Zust scripting language
-
rucc-abi
The psABIs for rucc, as descriptions read by one classifier rather than as one function per ABI
-
typst-eval
Typst's code interpreter
-
oxc_mangler
A collection of JavaScript tools written in Rust
-
mollify-parse
Python parsing for Mollify, built on Astral's ruff_python_parser/ruff_python_ast behind parser-agnostic types (see ADR-0001)
-
assura-resolve
Name resolution and symbol table for the Assura contract language
-
dust_dds_gen
OMG IDL compiler for Dust DDS
-
typst-timing
Performance timing for Typst
-
stak-compiler
Stak Scheme bytecode compiler
-
plotnik-compiler
Compiler for Plotnik query language (parser, analyzer, bytecode emitter)
-
garnish_lang
Single library for re-exporting and documenting all Garnish core libraries
-
tpt-telos
Command-line interface for the tpt-telos compiler
-
xur-vm
The bytecode interpreter of the Xur language
-
steel-gen
Code generation crates for use within steel
-
rucc-tuple
The ten field target tuple, the target table and the tier model for the rucc C compiler
-
forgellm-codegen-cpu
CPU code generation (x86 AVX2/512, ARM NEON) for ForgeLLM
-
caixa-ast
Span-aware Lisp AST for the caixa ecosystem — shared by caixa-fmt, caixa-lint, caixa-lsp. Compatible with tatara-lisp's Sexp.
-
lex-ast
Canonical AST + content-addressed identity for Lex programs
-
bynk-syntax
The syntax foundation of the Bynk compiler: lexer, parser, AST, spans, the CompileError type, and the diagnostic-code registry
-
rucc-regalloc
Both register allocators and the allocation checker
-
stak-dynamic
Dynamic primitives for Stak Scheme
-
ir-lang
SSA intermediate representation for native compilation: modules, calls, memory, exception edges, safepoints, SSA construction, statepoint insertion, a validator, a rewrite API, and a textual form
-
stak
Stak Scheme interpreter
-
oj_tsrs_sourcemap
tsrs's tsrs_sourcemap, vendored for oj's type checker
-
ion-core
Embeddable scripting language with a bytecode VM
-
etdl-compiler
ETDL compiler: IEC 61025 fault tree resolution, MOCUS cut sets, ECEL type-checking, semantic validation, and code generation for event-driven microservices
-
verse-rs
compiler and bytecode VM for a Verse-aligned language subset
-
tinymist-assets
assets for tinymist
-
lex-vcs
Agent-native version control: typed op log + attestation graph
-
swc_next_type_strip
TypeScript type stripping for erasable syntax
-
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
-
mpl-lang
Axioms Metrics Processing Language
-
blisp
A lisp like statically typed programing language for no_std
-
stak-configuration
Stak Scheme configuration
-
rusty-jvm
A Java Virtual Machine (JVM) implemented from scratch in Rust — interprets Java bytecode with no dependency on existing JVMs
-
fidget
Infrastructure for complex closed-form implicit surfaces
-
midenc-frontend-wasm-metadata
Shared frontend metadata codec for the Miden Wasm frontend
-
kn-cuda-eval
A CUDA executor for neural network graphs
-
runmat-static-analysis
Domain-specific static analysis passes for RunMat
-
calcit
Interpreter and JavaScript/WebAssembly codegen for Calcit
-
varyk
Build backend services simply and ship Rust binaries: an experimental language for APIs, workers, and microservices that compiles to Rust
-
hiko-harness
part of the hiko ML-family scripting 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
-
rucc-builtins
The libgcc-ABI-compatible runtime support library emitted code may call
-
monty-pool
A secure, snapshotable Python sandbox written in Rust
-
sema-core
Core types and environment for the Sema programming language
-
kz80_c
A self-hosting C compiler for Z80 targeting RetroShield hardware
-
zust-vm-spirv
SPIR-V code generation backend for the Zust scripting language
-
whisper-lang
Whisper: a compact stack-based programming language for AI
-
aver-lang
VM and transpiler for Aver, a statically-typed language designed for AI-assisted development
-
stak-module
Modules in Stak Scheme
-
wasm2rs
Transpile WebAssembly binaries into standalone native Rust source code
-
furiosa-opt-lower
Public interface for the furiosa-opt lowering engines
-
harn-signals
Per-machine signal inbox, session registry, and router for delivering alerts to running agent sessions
-
hir-lang
High-level IR for LexerSketch: the structured, typed-optional core every forged language lowers into
-
phper
The framework that allows us to write PHP extensions using pure and safe Rust whenever possible
-
stak-profiler
Profiling for Stak Scheme
-
zust-vm-metal
Metal shader source generation backend for the Zust scripting language
-
ts-native
TypeScript to native executable compiler - Stable Release
-
intent-cli
CLI toolchain for IntentLang: check, render, compile, verify, audit, query, lock, fmt, generate, init
-
vbrcc
A small C compiler with a hand-written x86-64 assembler and PE/COFF backend
-
smelt-hir
Shared high-level IR (HIR) types and validation for the Smelt transpiler
-
bynk-driver
The command bodies of the Bynk CLI: project rooting, check, fmt, test, and output writing
-
bbnf-ir
Canonical Grammar IR for the BBNF compiler pipeline
-
lamina-platform
Platform and target detection for Lamina compiler
-
runmat-vm
RunMat virtual machine and bytecode interpreter
-
tl-stream
Streaming and pipeline engine for ThinkingLanguage (Phase 4)
-
java_asm
Java bytecode reader & writer in rust
-
rune_c_compiler
A Rune to C source file compiler
-
hiko-syntax
part of the hiko ML-family scripting language
-
bend-lang
A high-level, massively parallel 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)
-
mech-set
Set library for the Mech language
-
han-lang
한글(Han) Korean-syntax programming language: interpreter, LLVM-IR codegen, and LSP
-
luaur
Luau (Roblox's typed Lua) implemented in Rust: compiler, VM, and type checker. Umbrella crate.
-
bcgen-lang
Compiles HIR to LSB bytecode: the path from a forged language's meaning to code bvm-lang runs
-
rucc-stub
Synthesizes the shared libraries a linker needs from a description of their exported interface, for rucc's self-contained cross compilation
-
tclrs
Tcl as a fusevm frontend: a parser and compiler to fusevm::Chunk, with no bespoke VM or JIT
-
stak-inexact
Inexact number operations for Stak Scheme
-
forthling
A Forth-2012 system in Rust: no dependencies, a sandbox, JSON words and a tutorial
-
oxc_parser_napi
A collection of JavaScript tools written in Rust
-
bhc-codegen
Code generation backend for BHC (LLVM backend)
-
forked_react_compiler_hir
Rust port of the React Compiler, vendored from react/react
-
southstar-boa-engine
Southstar's fork of boa_engine: Boa is a Javascript lexer, parser and compiler written in Rust. Currently, it has support for some of the language.
-
runar-compiler-rust
Rúnar compiler (full pipeline: .runar.ts → Bitcoin Script)
-
oonta
OCaml (subset) to LLVM IR compiler front-end
-
speccy
Heads over the spectrum core. For now: a themed terminal (TUI) head via the display pipeline.
-
brink-source-tree
SourceTree trait: a host-agnostic seam for enumerating and reading .brink source files
-
faye
a pretty lil lisp
-
kalua
Transpile Luau source code to Lua (kālua: cooking in an underground oven)
-
monty-runtime
A secure, snapshotable Python sandbox written in Rust
-
hugr-passes
Compiler passes for Quantinuum's HUGR
-
kn-runtime
Dynamic wrapper around CPU and GPU inference
-
lang-forge
LexerSketch: forge a working language front end - lexer, parser, and lossless syntax tree - from a .lsf schematic
-
monkey-parser
a parser for monkey lang
-
unluac
Multi-dialect Lua decompiler written in Rust
-
ilo
token-minimal programming language AI agents write
-
lift-predict
LIFT compiler performance prediction: analytical roofline model and budget enforcement for GPU/QPU workloads
-
vize_atelier_ssr
Vue SSR compiler for Vize
-
cljrs-compiler
JIT (Cranelift) and AOT compiler backend for clojurust
-
stak-lzss
LZSS compression for Stak Scheme
-
airl-cli
Command-line interface for AIRL: run, compile, type-check, patch, REPL, HTTP API
-
progenitor-middleware
An OpenAPI client generator
-
bock-ast
Abstract syntax tree definitions for the Bock language
-
deft-quick-js
QuickJS Javascript engine wrapper
-
lift-export
LIFT compiler backends: LLVM IR, ONNX (opset 21), OpenQASM 3 exporters; CUDA PTX and XLA planned
-
vexil-lang
Compiler library for the Vexil schema definition language — lexer, parser, IR, and type checker
-
node_resolver
Node.js module resolution algorithm used in Deno
-
typr
A typed superset of R - transpiler and type checker
-
bhc-ast
Abstract syntax tree definitions for BHC
-
cargo-codegen
Cargo subcommand for assembly-aware analysis: listings, instruction stats and baselines of a crate's probes
-
lamina-ir
Lamina Intermediate Representation — high-level typed IR for the Lamina compiler
-
masl_diagnostics
Maduka Authorization Specification Language (MASL) toolchain and runtime
-
pe-assembler
PE/COFF assembler for Windows instruction sets - strongly typed, object-oriented, zero-dependency core
-
masl_hir
Maduka Authorization Specification Language (MASL) toolchain and runtime
-
cedar-policy-symcc
Symbolic Cedar Compiler (SymCC): translates queries about Cedar policies to SMT
-
rustcc
An little C Complier( now it's just WIP :) )
-
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.
-
somatize-compiler
Graph-to-execution-plan compiler for the Soma runtime
-
smelt-stdlib
Shared standard-library shims and diagnostic categories used across the Smelt transpiler
-
heraclitus-compiler
Compiler frontend for developing great programming languages
-
forked_react_compiler_lowering
Rust port of the React Compiler, vendored from react/react
-
infr
A gradually typed superset of R
-
masl_ast
Maduka Authorization Specification Language (MASL) toolchain and runtime
-
t-backend_c
C code generator for the T programming language
-
t-parser_c
C-syntax parser for the T programming language
-
forked_react_compiler_validation
Rust port of the React Compiler, vendored from react/react
-
x86_64-assembler
Modern assembler for x64 and x86 instruction sets - strongly typed, object-oriented, zero-dependency core
-
hiko-types
part of the hiko ML-family scripting language
-
cyclang
toy language built in LLVM
-
smelt-frontend-ts
TypeScript frontend for the Smelt transpiler: lowers strict TypeScript to Smelt HIR via oxc
-
swc_cli
Commandline for SWC
-
seq-runtime
Runtime library for the Seq programming language
-
hi-doc
Diagnostics formatting library
-
reluxscript
Write AST transformations once. Compile to Babel, SWC, and beyond.
-
masl_ir
Maduka Authorization Specification Language (MASL) toolchain and runtime
-
yulang
Experimental language with Simple-Sub-style inference, algebraic effects, effect rows, roles, and Ruby/Perl/Raku-inspired syntax
-
dogelang
The Doge programming language — Python’s ease, Rust’s engine. Installs the
dogeCLI. -
mojito
A compact compiler and register VM for a CPU-focused subset of Mojo
-
kn-graph
A neural network inference graph intermediate representation, with surrounding utilities
-
monkey-interpreter
an interpreter for monkeylang
-
slicec
The Slice parser and other core components for Slice compilers
-
backend-lang
Native backend: instruction selection from ir-lang, SSA register allocation with stack maps, and x86-64 emission through isa-lang
-
duck-diagnostic
Generic diagnostic engine for building rich error reporting into any tool
-
gust-lang
The Gust programming language compiler — parse .gu state machine files and emit Rust, Go, WASM, no_std, or C FFI code
-
forgellm-codegen-gpu
GPU code generation via wgpu/WGSL for ForgeLLM
-
sema-eval
Trampoline-based evaluator and module system for the Sema programming language
-
tsbytes
Compile TypeScript directly to native JVM bytecode and executable JARs
-
elenchus-compiler
Compiles parsed elenchus DSL into a canonical Impossible/CNF clause IR: import resolution, desugaring, atom interning, content-addressed dedup
-
southstar-boa-parser
Southstar's fork of boa_parser: ECMAScript parser for the Boa JavaScript engine
-
resrap-rs
Seedable, grammar-based code and text generation
-
rubylang
Ruby as a fusevm frontend: lexer, parser, and compiler to fusevm::Chunk on a RubyHost heap — the first compiled standalone Ruby runtime
-
typst-ide
IDE functionality for Typst
-
urd
Dialogue scripting language for games — compiler, VM, and static analysis
-
tabnas-abnf
ABNF (RFC 5234) grammar compiler for the tabnas parsing engine: ABNF text in, tabnas GrammarSpec out
-
forked_react_compiler_inference
Rust port of the React Compiler, vendored from react/react
-
vimlrs
Faithful Rust port of the Vimscript (VimL) interpreter, from the Neovim C eval engine
-
virtual-rust
A virtual machine that interprets and runs Rust source code directly without compilation
-
haskelujah-backend-llvm
LLVM IR backend for the Haskelujah Haskell compiler
-
haskelujah-ast
Abstract syntax tree types and helpers for the Haskelujah Haskell compiler
-
kn-cuda-sys
A wrapper around the CUDA APIs
-
reticle
A from-scratch VHDL / Verilog compiler in pure Rust: frontends, a unified IR, simulation, synthesis and FPGA/ASIC backends, with first-class IP integration
-
rubyrs
A tiny Ruby-subset interpreter in Rust, built on top of Prism
-
miden-format
Formatter for the Miden Assembly language
-
metrowrap
A mwcc wrapper
-
sapphire-lang
Gradually typed scripting language where every value is an object and types are optional, checked at runtime
-
mlirpass
MLIR passes in Rust: mutable IR, pattern rewriting, dialect conversion and the upstream lowerings, on top of mlirformat
-
finlang
Command-line interface for the FinLang financial programming language
-
hiko-compile
part of the hiko ML-family scripting language
-
runmat-time
Cross-platform time utilities for RunMat (monotonic + wall-clock helpers)
-
cairn-lang-core
Core of the Cairn language: parser, IR, compiler
-
trit-core
三值逻辑核心：Kleene / Łukasiewicz / Bochvar 语义、AST、解析器、位并行表示与二进制互操作
-
latticefoundry
A clean-room compiler construction framework in pure Rust
-
adana
namespaces aliases for command lines & basic scripting language
-
tl-ast
Abstract Syntax Tree definitions for ThinkingLanguage
-
zdc-ast
The ZDeceptron syntax tree, and the spans every diagnostic points at
-
sqry-lang-shell
Shell script language plugin for sqry
-
hugr-cli
Compiler passes for Quantinuum's HUGR
-
gccjit_sys
Raw bindings to libgccjit. Companion to the gccjit crate.
-
kohebi
A Python runtime written in Rust, with a tiered JIT and an ahead-of-time compiler that emits Rust
-
forked_react_compiler_diagnostics
Rust port of the React Compiler, vendored from react/react
-
ty-parser
C-syntax parser for the Ty programming language
-
oak-typescript
TypeScript frontend for Oak
-
dolang-ext-winscm
Windows Service Control Manager extension for the Do language
-
masl_formatter
Maduka Authorization Specification Language (MASL) toolchain and runtime
-
qbe
QBE IR for Rust
-
atoxide-cli
Atopile compiler CLI
-
qir-qis
QIR to Quantinuum QIS (Quantum Instruction Set) compiler
-
bynk-project
The project model of the Bynk compiler: discovery, the unit dependency graph, path resolution, cross-unit consistency checks, and the schema-registry document
-
fta
Fast TypeScript Analyzer
-
oxc_transformer_plugins
A collection of JavaScript tools written in Rust
-
typst-library
Typst's standard library
-
beni
Typed Rust wrapper over the mruby C API, sitting on the
beni-sysbindgen surface -
lex-runtime
Effect handler runtime + capability policy for Lex
-
plotnik-bytecode
Bytecode format and runtime types for Plotnik
-
rustpython-codegen
Compiler for python code into bytecode for the rustpython VM
-
phew
Fast HTML + PHP formatter for Yii 2 view files
-
ternlang-cli
Command-line interface for ternlang — run, build, sim, fmt, repl, and compat commands for the Balanced Ternary Execution VM
-
lift-ast
LIFT compiler framework AST: lexer, parser, and AST for the .lif source language
-
monkey-lexer
a lexer for monkey lang
-
deno_webidl
WebIDL implementation for Deno
-
rl-parser
Parser for the rl-lang programming language
-
xliff2
XLIFF 2.0 read/write library
-
node-js
JavaScript as a fusevm frontend: a lexer/parser and compiler to fusevm::Chunk on a JsHost object heap, with no bespoke VM or JIT
-
monkey-object
a object system for monkey lang
-
dolang-private-util
Shared utilities for Do language crates
-
tabnas-ebnf
EBNF (W3C, plus the non-colliding ISO 14977 spellings) grammar front-end for the tabnas parsing engine
-
cfi-types
CFI types for cross-language LLVM CFI support
-
oxc_regular_expression
A collection of JavaScript tools written in Rust
-
libjuno
JunoLang
-
maat
programming language -- Rust-native syntax for writing zero-knowledge proofs
-
hiko-cli
part of the hiko ML-family scripting language
-
cargo-ats3
Cargo subcommand for ATS3 projects
-
haskelujah-th
Template Haskell AST types, Q monad, reification, and splice evaluation for the Haskelujah compiler
-
sabiruby
embeddable no_std Rust VM for mruby 4.1 bytecode ("rusted Ruby"), checked against mruby 4.1.0-rc2, with a Rust host API for defining classes and methods
-
strykelang
A highly parallel Perl 5 interpreter written in Rust
-
stak-minify
Stak Scheme source code minifier
-
generic-lang
A Lox based programming language
-
rust_lisp
A Rust-embeddable Lisp, with support for interop with native Rust functions
-
piccolo
Stackless Lua VM implemented in pure Rust
-
kirun
Rust runtime for KIRun: functions are JSON data, and the same definition runs in JavaScript, Java, Rust and Python
-
tinymist-world
Typst's World implementation for tinymist
-
luajit-ripper
A LuaJIT bytecode decompiler
-
neorusticus
A Prolog implementation in Rust with enhanced error handling
-
rsml-compiler
The translator behind rsml's macros: lexer, parser and code generator for ML-style syntax over Rust
-
harsh-lang
Harsh: Rust without braces -- with pipes, partial application, comprehensions and Julia-style linear algebra. A layout transformation over Rust, and back again.
-
Tres
Interpreter for the Tc2 esolang
-
praxis-stdlib
Method catalog schema and the Praxis prelude
-
lamina-weld
weld - Cross-platform linker. Fast, minimal, drop-in for ld/lld/mold. Links ELF (Linux), PE (Windows), Mach-O (macOS).
-
chiklisp
tools for working with chiklisp language; compiler, repl, python and wasm bindings
-
from-pest
Convert from a pest grammar to a typed AST
-
dlexer
A high-performance, functional parser combinator library for Rust
-
sema-vm
Bytecode compiler and virtual machine for the Sema programming language
-
lambda_mountain
Typed Macro Assembler (backed by Coq proofs-of-correctness)
-
kz80_lua
A Tiny Lua interpreter and compiler for RetroShield Z80
-
bicycle_random_numerics
Collect numerics for random Pauli-generated rotations run on the bicycle architecture
-
gluon_completion
Auto-completion for the gluon programming language
-
msl-minifier
Scope-aware minifier for Metal (MSL) shader source
-
glt
Glint compiler library
-
oxie
Command line tool and language server for the Oxie programming language
-
forgellm-codegen-wasm
WASM + WebGPU code generation for ForgeLLM
-
prune-lang
Prune is a constraint logic programming language with branching heuristic
-
bhc-core
Core IR - typed, explicit intermediate representation for BHC
-
windjammer
language inspired by Go, Ruby, and Elixir that transpiles to Rust - 80% of Rust's power with 20% of the complexity
-
ripex
Multi-language structural parsing and fact extraction
-
lykn
A modern Lisp for ECMAScript, the browser, and the Deno JavaScript runtime
-
gluon_parser
The parser for the gluon programming language
-
installua
A Lua-shaped language that compiles to NSIS
-
wolfpack-lang
Wolfpack: a language that compiles to readable TypeScript, Go and Rust. The wolf command
-
forked_react_compiler_optimization
Rust port of the React Compiler, vendored from react/react
-
stak-minifier
Stak Scheme source code minifier
-
llvm-in-rust-codegen
Machine-independent code generation infrastructure for LLVM-in-Rust
-
lumen-vm
The AI-Native Programming Language
-
a2x
A converter from ALFA to XACML policy language
-
elworthy
JIT compiler that specialises Bismut-Elworthy-Li formulas into SIMD kernels for unbiased Monte Carlo Greeks on non-stationary SDEs
-
framec
Frame language transpiler — state machines that generate production code
-
monkey-wasm
monkey lang parser wasm version
-
crush-lang-python
Python language support for Crush — parser + CAST lowering backed by rustpython-parser
-
encore_compiler
Encore compiler — CPS IR pipeline for the Fleche functional language
-
somni-parser
Grammar parser of the Somni language and VM
-
t4a-cubecl-cpp
CPP transpiler for CubeCL
-
rajac-base
Shared foundational utilities for the rajac compiler workspace
-
equilibrium-ffi
Automatic C FFI generation for C-compiling languages (V, Zig, C++, C#, Rust, D, Nim, Odin, Hare, and TypeScript/JavaScript via scriptc) (unstable and in development)
-
struo
Logic synthesis toolkit from Veryl to FPGA targets
-
trit-eval
三值求值、真值表与化简
-
oak-dhall
Dhall language parser with support for functional programming and type system features
-
edlc_core
Core library for the EDL compiler
-
bhc-lower
AST to HIR lowering for BHC
-
pythonrs
Python as a fusevm frontend: lexer, parser, and compiler to fusevm::Chunk on a PyHost heap — the first compiled standalone Python runtime
-
sema-reader
Lexer and s-expression parser for the Sema programming language
-
lift-cli
LIFT compiler CLI: verify, analyse, optimise, print, compile, simulate, and predict from the command line
-
runmat-turbine
Cranelift-based JIT compiler for RunMat - the optimizing tier of our V8-inspired execution model
-
rl-vm
Bytecode virtual machine for the rl-lang programming language
-
lc3as
Assembler for the LC-3 that translates assembly source into big-endian object files
-
masl_lsp
Maduka Authorization Specification Language (MASL) toolchain and runtime
-
phplang
PHP as a fusevm frontend: lexer, parser, and compiler to fusevm::Chunk on a PhpHost heap — the first compiled standalone PHP runtime
-
bhc-hir-to-core
HIR to Core IR lowering for BHC
-
alder-solve
The entry point of alder's type inference system. Implements type inference and specialization of traits.
-
oxc_isolated_declarations
A collection of JavaScript tools written in Rust
-
lustc
A Lean4 subset to Rust source-to-source compiler
-
bock-source
Source file management and FileId mapping for the Bock language compiler
-
turbofuro_worker
Worker executable for Turbofuro
-
i18n-rust-engine
多语言 Rust 教学方言核心引擎：词法转译、映射管理、诊断翻译、增量缓存
-
muga
A quiet programming language
-
csml_engine
The CSML Engine is a conversational engine designed to make it extremely easy to create rich and powerful chatbots
-
thinkinglanguage
CLI entry point for ThinkingLanguage (tl run, tl shell)
-
llvm-pm
Safe Rust wrapper for LLVM new PassManager
-
parlex-gen
Lexer generator ALEX and parser generator ASLR
-
bitloom
CLI (crates.io: bitloom; cargo subcommand binary cargo-bitloom). Unrelated to samitbasu/rhdl.
-
hugr-llvm
A general and extensible crate for lowering HUGRs into LLVM IR
-
praxis-hir
Name resolution and high-level intermediate representation for Praxis
-
luaur-vm
The Luau register virtual machine and standard library (Rust)
-
draxl
Agent-native source annotation for semantic program control
-
stak-libc
Stak Scheme libc utilities
-
matchcov
Language-agnostic usefulness and exhaustiveness analysis for pattern matching
-
moonseed
Deterministic, checkpointable Lua 5.4 runtime in safe Rust
-
atc-router
Versatile DSL based rule matching engine used by the Kong API Gateway
-
forgellm-optimizer
Graph-level optimizations for ForgeLLM (fusion, layout, quantization, memory planning)
-
php-rs-parser
Fast PHP parser producing a typed AST
-
scryer-prolog
A modern Prolog implementation written mostly in Rust
-
tsuki
Lua 5.4 ported to Rust
-
masl_linter
Maduka Authorization Specification Language (MASL) toolchain and runtime
-
patch-rexx
A modern REXX interpreter in Rust
-
lift-core
LIFT compiler framework core: unified SSA intermediate representation (IR) for AI and quantum — types, values, operations, blocks, regions, verifier
-
forked_react_compiler_ssa
Rust port of the React Compiler, vendored from react/react
-
verter_span
Typed span primitives for Verter — compile-time safety for position encoding
-
lady-deirdre
Compiler front-end foundation technology. Main Crate.
-
windy-lang
Windy — a 2D esoteric programming language where code flows like wind
-
darklua
Transform Lua scripts
-
oxc_ecmascript
A collection of JavaScript tools written in Rust
-
swfasm-cli
A command line tool that compiles a textual representation into SWF files
-
beamr
runtime with the BEAM's execution model, targeting Gleam
-
warble
front-end compiler: parse/resolve/validate a behavior profile into language-neutral IR (sans-IO)
-
rowl
Parser for the Dolfin Ontology Language
-
luaur-compiler
Luau source-to-bytecode compiler (Rust)
-
lex
aids in parsing programming languages
-
module-lang
Module and import resolution for multi-file languages
-
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
-
blue-lang-kiwari
kiwari, blue's one grammar spec: the spec-driven lowering of a concrete syntax tree to blue's tatara-lisp tree, and the differential that holds the emitted tree-sitter grammar to blue's parser
-
decy-codegen
Rust code generation from HIR with minimal unsafe blocks
-
viper-py
A fast Python interpreter written in Rust
-
bf-frontend
Lexer, parser, and AST for the bf-lab Brainfuck toolchain
-
zhc_utils
ZHC: Shared utilities
-
nightjar-lang
A declarative, prefix-notation DSL for formal verification of structured data
-
vexlang
Alpha interpreter and typed IR prototype for the Vex language
-
littrs-ruff-python-parser
Vendored ruff_python_parser for littrs (from github.com/astral-sh/ruff)
-
luaur-bytecode
Luau bytecode format and builder (Rust)
-
tl-compiler
Bytecode compiler and VM for ThinkingLanguage (Phase 2)
-
librasm
using RASM
-
slate-c2rust
A C to Rust transpiler with a built-in C frontend
-
lolrust
A transpiler from .meow (lolcat Rust) to valid Rust. i can haz rust?
-
tyre-tyr
Tyr CLI
-
typst-bundle
Bundle exporter for Typst
-
pliron-llvm
LLVM dialect for pliron
-
etdl-target-go
ETDL Go target: generates a Go developer API (structs, interfaces, orchestration functions) bound via cgo to the same compiled Rust ETDL runtime the Rust target consumes. Pure Rust…
-
dex2rs
Convert selected methods of an Android APK or DEX into Rust/JNI native code, then build, repack and sign
-
brink-compiler
Compiler for inkle's ink narrative scripting language
-
ternlang-compat
Compatibility bridges for the ternary ecosystem — .tasm 9-trit assembler → BET bytecode, Owlet S-expression front-end
-
oj_tsrs_transformers
tsrs's tsrs_transformers, vendored for oj's type checker
-
gust-lsp
Language Server Protocol (LSP) implementation for the Gust state machine language
-
assura
Contract-first AI-native language. Write what it should do. AI proves it does.
-
leo-parser-rowan
Rowan-based lossless parser for Leo
-
beadie
Hot-function promotion broker for interpreter-to-JIT tiering
-
typescript-ir
Intermediate representation for TypeScript compiler
-
uxn-tal
uxntal:// protocol | a Rust library for assembling TAL (Tal Assembly Language) files into UXN ROM files
-
flamelang
A statically typed, fast, and modern programming language built in Rust
-
mist-lang
The Mist programming language compiler
-
t-lang
T: like C, but a different letter. A small no-GC language built one type-theory concept at a time.
-
lang-util
implementing parsers and ASTs using lalrpop
-
crush-cosm
COSM — the Crush Object Semantic Model: declarative, serializable object declarations (Kinds), validation and C3 linearization
-
lex-trace
Run-time trace tree + replay for Lex programs
-
tel
Turbofuro Expression Language
-
analyssa
Target-agnostic SSA IR, analyses, and optimization pipeline
-
c2rust-ast-builder
Rust AST builder support crate for the C2Rust project
-
ringkernel-cuda-codegen
CUDA code generation from Rust DSL for RingKernel stencil kernels
-
maat_trace
Trace-generating virtual machine for the Maat programming language
-
pyimports
Parse and analyze the imports within a python package
-
glua_parser
Parser for Garry's Mod Lua, Lua 5.x, and LuaJIT source files
-
qala-cli
Command-line interface for the Qala programming language
-
rscc
A fast and modular C compiler written in Rust targeting x86_64 and AArch64
-
vplsfpoael
the best programming language (joke)
-
st8
Stator JavaScript shell — interactive JS REPL and script runner (like V8's d8)
-
cargo-abi-audit-cli
Cargo-native Rust/native ABI auditing CLI, scoped honestly to a C-ABI-first workflow
-
forked_react_compiler_reactive_scopes
Rust port of the React Compiler, vendored from react/react
-
oak-lua
High-performance incremental Lua parser for the oak ecosystem with flexible configuration, supporting lightweight scripting and embedded development
-
bf-codegen
Compile Brainfuck source into freestanding C with the BFNI ABI
-
opt-lang
SSA optimization passes for ir-lang: sparse conditional constant propagation, value numbering, dead-code elimination, CFG simplification, copy propagation, and loop-invariant code motion
-
oxc_estree
A collection of JavaScript tools written in Rust
-
auv-auto-loop
AUV auto-loop v0.1: trajectory compiler, compilation gates, fast loop scheduler, and runtime auto-isolation
-
erg_common
A common components library of Erg
-
airl-typecheck
Bidirectional type checker for AIRL IR with effect tracking
-
lmntalc
A compiler for the LMNtal language
-
ling-gpu
GPU compute backend for Ling (CUDA via cudarc, with a portable CPU fallback)
-
llvmkit-ir
LLVM IR data model in pure Rust: types, values, modules, instructions, builder
-
oak-scheme
Scheme functional programming language parser with support for Lisp dialect and symbolic computation
-
grabapl
graph-based programming languages, with pluggable type systems and a focus on visible intermediate states
-
gluon_vm
The virtual machine for executing the gluon programming language
-
slac
The "Simple Logic & Arithmetic Compiler" transforms a single expression into an abstract syntax tree
-
etdl-target-python
ETDL Python target: generates a Python developer API (dataclasses, ABC handler interfaces, orchestration functions) bound via stdlib ctypes to the same compiled Rust ETDL runtime the Rust target consumes…
-
formalang
An embeddable compiler frontend for FormaLang: lexer, parser, semantic analysis and IR lowering
-
midenc-hir-opt
parsing and rewriting HIR
-
wasm-pvm-cli
CLI for WASM to PVM recompiler
-
knave
A Lisp programming language for humans and agents that infers types and ownership and compiles to readable Rust
-
tabnas-alchemy
The alchemy grammar plugin and language for the tabnas parsing engine (declarative streaming transducers and renderers), and the types tabnas transducers and renderers share
-
airlang_bin
Air is a universal, reliable, and lean programming language
-
preinterpret
An intuitive toolkit to simplify code generation development
-
tl-package
Package manager for ThinkingLanguage
-
verter_core
Vue 3 SFC compiler - transforms Vue Single File Components to render functions with TypeScript support
-
rucc-targets
Target and psABI queries for the rucc C compiler, and the generator for docs/TARGETS.md and docs/FEATURES.md
-
dlwrap
dlopen wrapper code generator
-
forge-lang
Forge — Internet-native programming language with natural syntax, bytecode VM, and built-in HTTP/database/crypto
-
aardvark-core
Runtime for executing sandboxed python bundles inside V8
-
assura-codegen
Rust code generation from type-checked Assura contracts
-
ringkernel-ir
Intermediate Representation for RingKernel GPU code generation
-
maat_bytecode
Bytecode format and serialization for the Maat virtual machine (MVM)
-
forgellm-runtime
Minimal runtime for ForgeLLM (KV cache, sampling, tokenizer, API server)
-
xqasm
Assembler for the XQuad Toolchain
-
lumen-compiler
The AI-Native Programming Language
-
cljrs-jit
In-process JIT compiler (Cranelift) for clojurust — Phase 10.1
-
funct
A small, functional, embeddable scripting language with a fully reified bytecode VM you can pause, snapshot, and resume
-
archscript
programming language — Python-like syntax, Haskell-inspired features, Arch Linux integration
-
phenotyper
Core compiler library for the Phenotyper structural artifact definition language
-
codegen-lang
Backend abstraction targeting LLVM, Cranelift, or bytecode
-
cubecl-llvm
LLVM compiler for CubeCL
-
ghci
Manage and communicate with ghci (Haskell's GHC interpreter)
-
tl-data
Data engine for ThinkingLanguage — DataFusion, connectors, I/O
-
xbasic64
A BASIC-to-x86_64 native code compiler targeting 1980s-era BASIC dialects
-
gluon_check
The typechecker for the gluon programming language
-
miden-objtool
Common utilities for analyzing Miden artifacts
-
diplomat-tool
generating FFI bindings for various languages
-
rl-lexer
Lexer and tokenizer for the rl-lang programming language
-
monty-proto
A secure, snapshotable Python sandbox written in Rust
-
airl-project
Project and workspace management for AIRL: history, queries, projections
-
grove-compiler
Season-based compiler pipeline with ternary bytecode — Spring→Summer→Autumn→Winter
-
hel
Heuristic Expression Language: a deterministic, auditable expression language & parser, AST, builtin registry and evaluator
-
maat_ast
Abstract syntax tree (AST) for the Maat programming language
-
ty-ree
AST definitions for the Ty programming language
-
koto
expressive, embeddable programming language
-
stator_jse_ffi
Stator JavaScript engine — stable C FFI layer for embedding
-
miju-services
Application assembly, service lifecycles, owned work, and resource cleanup for miju
-
luaur-analysis
Luau type checker and type inference (Rust)
-
marigold
Programming Language
-
langkit
A builder library for creating programming languages in Rust
-
oak-html
HTML markup language parser with support for web content and document structure processing
-
gluon_c-api
C-api for gluon, a static, type inferred programming language for application embedding
-
endbasic
programming language - CLI
-
galvan
A higher-level programming language that transpiles to Rust
-
tyre-ty
Ty compiler CLI
-
gluon_format
Code formatting for the gluon programming language
-
tl-ai
AI/ML integration for ThinkingLanguage — tensors, training, inference, LLM
-
py5
A minimalist Python interpreter written in Rust
-
scheme4r
Scheme interpreter for rust
-
lift-import
LIFT compiler importers: PyTorch FX, ONNX, Qiskit, and OpenQASM 3 frontends
-
forked_react_compiler_typeinference
Rust port of the React Compiler, vendored from react/react
-
vyre-lower
Substrate-neutral lowering: vyre Program → KernelDescriptor consumed by vyre-emit-* crates
-
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…
-
typescript
compiler and runtime
-
spade-ast
Helper crate for https://spade-lang.org/
-
decy-ownership
Ownership and lifetime inference for C-to-Rust conversion (CRITICAL)
-
hiko-vm
part of the hiko ML-family scripting language
-
nextjs_react_compiler_lowering
Rust port of the React Compiler, vendored from facebook/react
-
stoffel-rust-sdk
Rust SDK for building Stoffel MPC applications
-
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).
-
ternlang-hdl
Verilog-2001 codegen for balanced ternary — BET processor primitives, sparse matmul array, FPGA simulation wrapper
-
loom_ruleset
Deterministic data-driven ruleset AST interpreter for the Loom Engine (the Any-System core)
-
stak-profile
Stak Scheme profiler
-
gluon_base
Basic type definitions and functions for the gluon programming language
-
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.
-
bynk-lower
The helpers that build the Bynk emitter's declaration-level IR (bynk-ir) from a checked program. Final crates.io release; superseded by bynk-model.
-
motto
Compiler-as-a-Service: Turn Rust schema.rs into multi-platform SDK toolkits
-
bhc-tensor-ir
Tensor IR for numeric optimization in BHC
-
zio-core
Zio language core: reader, evaluator, ZOS object system, and the self-hosted compiler and instruction runtime
-
run-kit
Universal multi-language runner and smart REPL
-
oak-csharp
C# frontend for Oak
-
nova-cli
The Nova programming language: compiler to native code and to WebAssembly for the web, dev server, formatter, language server, package manager and documentation generator
-
oxc_napi
A collection of JavaScript tools written in Rust
-
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
-
ai-sentinel
Compilation wrapper used to fix misc compilations bugs
-
tsz-parser
TypeScript parser and AST types for the tsz compiler
-
kind2
A pure functional functional language that uses the HVM
-
passerine
A small extensible functional scripting language designed for concise expression with little code
-
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… -
decy-verify
Safety property verification for transpiled Rust code
-
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
-
cranelift-reader
Cranelift textual IR reader
-
oxc_transform_napi
A collection of JavaScript tools written in Rust
-
bitis
Bitwise serialization of messages defined in a data description language with interfaces for rust, python and c++
-
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… -
lift-opt
LIFT compiler pass manager: 13 optimisation passes — constant folding, DCE, CSE, tensor fusion, gate cancellation, qubit routing
-
type-sitter-cli
CLI for type-sitter (generate typed wrappers for tree-sitter grammars from node-types.json and queries)
-
m68000
A Motorola 68000 interpreter, disassembler and assembler (code emitter)
-
ascent-interpreter
Interpreter and JIT for Ascent Datalog programs
-
catallaxy
programming language: a statically typed, Ruby-flavored language whose threads run truly in parallel
-
airl-patch
Semantic patch engine for AIRL IR: apply, validate, and invert structural edits
-
intent-codegen
Skeleton code generator for IntentLang specifications (Rust, TypeScript, Python, Go, Java, C#, Swift)
-
t-parser_sln
SLN-syntax parser for the T programming language
-
tinymist-debug
Tinymist debug support for Typst
-
llvm-ir
LLVM IR in natural Rust data structures
-
lucia-lasm
LASM - Lucia Assembly Language
-
valua-ast
Lua 5.5 AST node definitions shared across the valua pipeline (Lua 5.4 is a supported subset)
-
rucc
An optimizing C compiler written in Rust, targeting real projects from SQLite to the Linux kernel
-
sbnf
A BNF-style language for writing sublime-syntax files
-
parlex
Core support library for parsers and lexers generated by parlex-gen
-
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…
-
pielang-cli
Pie language interpreter CLI
-
oak-d
High-performance incremental D language parser for the oak ecosystem with flexible configuration, supporting systems programming and native development
-
oj_tsrs_binder
tsrs's tsrs_binder, vendored for oj's type checker
-
voce-schema
Voce IR schema definitions and generated FlatBuffers bindings
-
oak-tcl
Tcl language parser with support for scripting, command substitution, and procedural programming features
-
baracuda-cuda-emit
CUDA backend for the neutral
unpoppedkernel generator: theCudaBackend(IR -> .cu emitter), the NVRTC on-demand JIT compiler (NvrtcCompiler). The Fuel kernel-seamSynthesizerimpl (BaracudaSynthesizer)… -
oxc_str
A collection of JavaScript tools written in Rust
-
russl
Rust Shader Language: shaders in Rust syntax, compiled at build time to WGSL and native shader languages
-
draxl-cli
Command-line interface for Draxl
-
oak-javascript
JavaScript frontend for Oak (reuses TypeScript implementation)
-
oak-cpp
C++ systems programming language parser with support for modern C++ features and object-oriented programming
-
tyr-backend_ty
Tyr to Ty compiler
-
tyre-t
T compiler CLI
-
hugr-model
Data model for Quantinuum's HUGR intermediate representation
-
mini-c-parser
minimal C language lexer & parser & virtual executer from scratch
-
typst-batch
Typst helper library for batch processing — friendly API, shared resources, virtual files, customizable diagnostics
-
ty-parser_sln
SLN-syntax parser for the Ty programming language
-
irvm
A IR compiler target with a Rust friendly API that lowers to LLVM IR
-
mutica
programming language
-
oxc_cfg
A collection of JavaScript tools written in Rust
-
yagbas
compiler for a language of the same name
-
nilang
A scripting language interpreter for Advent of Code
-
scc-plugin-api
Stable SCC plugin contracts: manifest, permissions, operation declarations
-
pfcl-repl
PFCL REPL and file runner — pure functional language with content-addressed catalog
-
oxc_minify_napi
A collection of JavaScript tools written in Rust
-
noise-core
Core of the Noise probabilistic language: lexer, parser, evaluator, sampler
-
nashc
Compiler for the nash programming language
-
doge-compiler
Compiler for the Doge programming language — lexer, parser, semantic checks, and Rust codegen
-
MotoGarage_parser
A parser and interpreter for MotoGarage DSL, a language for managing motorcycle collections
-
pascal
A modern Pascal compiler with build/intepreter/package manager built with Rust
-
tl-errors
Error types and diagnostics for the ThinkingLanguage compiler
-
vize_atelier_jsx
Atelier JSX - Shared JSX/TSX lowering layer for Vize
-
bhc-intern
String interning for efficient symbol handling
-
single-variable-algebra-compiler
A compiler for the minimalistic programming language single-variable-algebra
-
lightvm
A capability-based virtual machine designed for secure, predictable, and optimized bytecode execution
-
crush-lint
AI-augmented linter for Crush — a thin hint layer over the real crush-frontend parser and semantic checks
-
moore-svlog-syntax
The SystemVerilog parser implementation of the moore compiler framework
-
graphcal
Type-safe, unit-aware, Git-friendly reactive programming language for engineering calculations
-
stak-compile
Stak Scheme bytecode compiler
-
TypeScript-Rust-Compiler
High-performance TypeScript to Rust compiler
-
ocaml-gen
generating OCaml code
-
intent-ir
Agent IR lowering, verification, and audit bridge for IntentLang
-
stak-decode
Stak Scheme bytecode decoder
-
leo-abi-types
ABI type definitions for Leo programs
-
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.
-
monty-types
A secure, snapshotable Python sandbox written in Rust
-
monkey-compiler
a compiler for monkeylang
-
moore-vhdl-syntax
The VHDL parser implementation of the moore compiler framework
-
tl-lexer
Lexer/tokenizer for ThinkingLanguage
-
monty-fs
A secure, snapshotable Python sandbox written in Rust
-
axonyx-lsp
Persistent language server for Axonyx .asx and .ax source files
-
bock-errors
Diagnostic error types and source span machinery for the Bock language compiler
-
gonidium
A DSL compiler and REPL for typed numeric expression pipelines
-
gust-build
Cargo build-script integration for compiling Gust .gu files during cargo build
-
mirascript-vm
Native Rust virtual machine for MiraScript
-
gust-mcp
Model Context Protocol (MCP) server exposing the Gust compiler to AI-assisted development tools
-
bock-types
Type system, type checking, and inference for the Bock language
-
zamin
programming language interpreter
-
typlite
Converts a subset of typst to markdown
-
velme-syntax
Velme: syntax crate (see docs/spec/compiler/20-compiler-architecture.md)
-
script-format
DSL to format data via rhai scripting
-
dwanim-state
Rust-core + Python DSL video renderer
-
ferro-jtype
Type inference for Java class bytecode without JDK symbols
-
oak-kotlin
Kotlin language support for Oak
-
masl_compiler
Compiler, code generator and semantic validator for the Maduka Authorization Specification Language (MASL)
-
zust-vm
Cranelift JIT runtime for executing Zust modules
-
rune-modules
Native modules for Rune, an embeddable dynamic programming language for Rust
-
crush-caison
Crush VM host capability for CAISON (formerly CSON) parsing — the format types/parser/printer now live in the standalone
caisoncrate; this crate keeps only thecson.parsecapability and re-exports caison -
type-lang
Type representation, unification, and inference scaffolding
-
tishlang_compile
Tish native compiler backend
-
maat_vm
Stack-based virtual machine for the Maat programming language
-
janetrs
High level binding for Janet programming language
-
rl-resolver
Name and import resolution for the rl-lang programming language
-
proto-blue-codegen
AT Protocol code generator: Lexicon JSON -> Rust source
-
crush-jit
Cranelift-based JIT execution engine for the Crush VM — compiles a lowered FastVM program to native code and executes it, producing the same result the FastVM interpreter would
-
brvm
Brainrot language compiler and virtual machine
-
aleph2py
Transpiler Aleph to python
-
nextjs_react_compiler
Rust port of the React Compiler, vendored from facebook/react
-
zerodds-lang-rules
Maps the common AST onto the language CSTs through rules that are data, not code: seesaw v2 rule specifications, comparable and checkable
-
bhc-span
Source location tracking and span management for BHC
-
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.
-
oak-lean
Lean theorem prover language parser with support for dependent types and formal verification
-
regulus
interpreted language with very simple syntax and zero dependencies
-
brink-runtime
Runtime/VM for executing compiled ink stories
-
bicycle_numerics
Compute numerics for bicycle circuits
-
jzero
A compiler and bytecode VM for the Jzero language (a subset of Java)
-
casm
Crush Assembly (CASM) — bytecode format for the Crush VM
-
decy-stdlib
C standard library prototypes for the Decy C-to-Rust transpiler
-
brink-syntax
Syntax types and parser for inkle's ink narrative scripting language
-
oak-msil
Microsoft Intermediate Language (MSIL) parser with support for .NET Common Language Infrastructure and bytecode analysis
-
hilang
A small programming language
-
uffda-runtime
Uffda pattern/expression runtime, resolver, formatter, and data codec
-
aver-lsp
LSP server for the Aver programming language
-
encore_fleche
Fleche language parser — lexer and parser producing Encore compiler IR
-
zerodds-lang-render
Renders a language CST to text. Decides nothing: every decision sits in a rule and is therefore visible.
-
scopegraphs
A well-documented port of scopegraphs to Rust
-
bhc-loop-ir
Loop IR for vectorization and low-level optimization in BHC
-
somni
scripting language and VM
-
rgsm
An assembler for the Gheith ISA written in Rust
-
rustpython-jit
Experimental JIT(just in time) compiler for python code
-
rusty-javac
A Java compiler written in Rust
-
regorust
Rust bindings for the rego-cpp Rego compiler and interpreter
-
ling-physics
Physics, world generation, and hyperbolic geometry for Ling
-
stak-interpret
Stak Scheme bytecode interpreter
-
aegis-lang
A dynamic, interpreted programming language with a high-performance bytecode VM
-
gust-runtime
Runtime support library (traits, envelopes, supervisors) for programs compiled from Gust
-
sym-bridge
Sym client for Rust - use any language's libraries from Rust
-
tinymist-lint
A linter for Typst
-
stak-repl
Stak Scheme REPL
-
vyre-emit-ptx
PTX text emitter for vyre KernelDescriptor. Produces NVRTC-compatible CUDA assembly.
-
kz80_microperl
A minimal Perl interpreter and compiler for RetroShield Z80
-
three_body_lang
Three Body Language written in Rust
-
tket2
Quantinuum's TKET2 Quantum Compiler
-
vize_armature
Armature - The structural parser framework for Vize Vue templates
-
dolang
Embeddable public API for the Do language
-
tishlang_opt
AST optimization pass for Tish (constant folding, short-circuit, etc.)
-
dolfin-diagnostic
Unified diagnostic types for the Dolfin toolchain
-
valua-polyfills
Embedded Lua polyfill strings for Lua 5.5 → 5.1 transpilation
-
jit-codegen
Code generator for arm64jit instruction metadata
-
maat_errors
Compiler error types and diagnostic infrastructure for the Maat programming language
-
nextjs_react_compiler_diagnostics
Rust port of the React Compiler, vendored from facebook/react
-
mstak-interpret
Minimal Stak Scheme bytecode interpreter
-
frontend
rustc's frontend with no LLVM and no std: parsing through MIR, as a library
-
oak-python
Hand-written Python frontend
-
mstak
Minimal Stak Scheme interpreter
-
asmkit-rs
Portable assembler toolkit for encoding x86/x64, AArch64, and RISC-V
-
guryvsr
esoteric programming language gur yvsr
-
cirq-ir
Canonical Cirq IR — the resolved, validated semantic representation
-
llvm-infra
LLVM Compiler Infrastructure in Rust
-
michaelb/sniprun
A neovim plugin to run lines/blocs of code (independently of the rest of the file), supporting multiples languages
-
tofas
Translation of fundamental astronomical subroutines
-
rspression
A high-performance, lightweight expression calculation engine
-
turbofuro_runtime
Runtime for Turbofuro visual programming language
-
vize_atelier_core
Atelier Core - The core workshop for Vize Vue template parsing, transform lanes, and code generation
-
depyler-analysis
Analysis, type inference, and optimization passes for the Depyler transpiler
-
maat_span
Source span and location types for the Maat compiler
-
lykn-cli
Lykn language CLI — scaffolding, building, testing, and publishing for Lykn projects
-
garden-lang
A live programming language
-
tsz-binder
TypeScript name binder for the tsz compiler
-
cortex-lang
interpreted language for interfacing with Rust code
-
assura-types
Type checking for the Assura contract language
-
garble_lang
Turing-Incomplete Programming Language for Multi-Party Computation with Garbled Circuits
-
intent-check
Semantic analyzer and type checker for IntentLang specifications
-
stck
An embeddable interpreted language written fully in rust
-
ferropascal
A Pascal-to-Rust transpiler that converts Borland Pascal source code into idiomatic Rust
-
ale_python_parser
Python Parser : generate Aleph Syntax Tree
-
valua-parser
Recursive-descent Lua 5.5 parser for the valua transpiler
-
depyler-ruchy
Ruchy script format backend for Depyler Python-to-Rust transpiler
-
codex-empirica-plugin
ecodex's empirica plugin host — codex hook integration that runs the epistemic Sentinel firewall, transaction lifecycle, and subagent routing
-
god-graph
A graph-based LLM white-box optimization toolbox: topology validation, Lie group orthogonalization, tensor ring compression
-
tsz-common
Common types and utilities for the tsz TypeScript compiler
-
decy-repo
GitHub repository transpilation with parallel processing
-
harper-comments
The language checker for developers
-
rucc-safe-rt
The memory safety runtime: the planes, the allocator and the reporter
-
tishlang_bytecode
Bytecode compiler for Tish (AST → bytecode)
-
praxis-repr
The bridge between a static Praxis type and its runtime type descriptor
-
naga-rust-back
Backend for the Naga shader translator which generates Rust code
-
fhy-core-py
The PyO3 binding of fhy-core as a library: registers fhy_core's Python classes into an extension module
-
valua-lint
Static analysis lints for the valua transpiler. Public crate; stable from 1.0.
-
cardiac
Rust on CARDIAC, the classic 1968 cardboard computer from Bell Labs
-
genotype_parser
Genotype language parser crate
-
decy-agent
Background daemon for incremental transpilation and watching
-
ananse
WebAssembly-native zero-knowledge virtual machine (zkVM)
-
lumen-provider-env
The AI-Native Programming Language
-
valua-diagnostics
Diagnostic types and reporting for the valua transpiler
-
decy-book
Book-based verification for transpiled Rust code
-
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.
-
tripley-rpc-idlc
Compiler and plugin host for Tripley RPC IDL
-
decy-mcp
MCP server for Claude Code integration
-
voce-validator
Voce IR reference validator and CLI toolchain
-
xdl-parser
XDL/IDL language parser
-
jjik
LR(1) parser generator
-
nextjs_react_compiler_ssa
Rust port of the React Compiler, vendored from facebook/react
-
create-farm
Create Farm cli tool
-
oak-nim
Nim language parser with support for modern Nim syntax and systems programming features
-
grepdef
Quick search for symbol definitions in various programming languages
-
trans_py_c
Python subset → C transpiler for OS kernel and embedded development
-
bund
Interpreter and CLI for a Virtual Machine for BUND programming language
-
cgrammar
A comprehensive C language grammar parser library written in Rust, implementing the C23 standard (ISO/IEC 9899:2023)
-
kz80_smalltalk
Tiny Smalltalk to Z80 compiler for RetroShield hardware
-
wasc
A C-like language compiler for WebAssembly with first-class support for references and tables
-
luaur-compile-cli
Command-line Luau source-to-bytecode compiler (Rust)
-
zerodds-lang-cst
Concrete syntax trees for the 21 target languages of Language::ALL. Built, never parsed; typed construction with no string escape hatch.
-
cream-js
A lightweight compiler for modern web applications
-
voce-compiler-webgpu
Voce IR WebGPU compiler — compiles 3D scene IR to WebGPU render pipelines
-
ralix
type-safe, tree walking interpreter
-
backyard-nodes
Nodes representing PHP code AST
-
ternary-compiler-optimizer
Optimization passes for ternary bytecode
-
mist-codegen
The Mist programming language Rust code generator
-
gust-stdlib
Standard library of reusable Gust state machines (circuit breaker, retry, saga, rate limiter, and more)
-
tk-pg-qm-tableau
Clifford tableaux with a qubit major memory layout
-
aver-rt
Shared Rust runtime pieces for Aver-generated programs
-
oak-objective-c
Objective-C object-oriented programming language parser with support for Apple platform development and runtime features
-
antimony-lang
The Antimony programming language
-
typelisp-print
Common Lisp style printer (format directives and pretty printer) of typelisp. Internal crate of typelisp; not meant to be used directly.
-
flux-isa
FLUX Instruction Set Architecture — stack-based constraint compilation VM with bytecode encoding
-
lambda-expr
evaluating string expressions in hot loops
-
diffsl
A compiler for a domain-specific language for ordinary differential equations (ODE)
-
remir
MIR library designed to be used easily and be efficient
-
depyler-verify
Property verification and formal methods for Depyler transpilation
-
zen-expression
Zen Expression Language
-
qleisli
Experimental quantum language with linear ownership, exact contracts and independent finite IR verification
-
sigil-parser
Parser and native compiler for the Sigil programming language
-
fpp_parser
Recursive descent AST parser for the FPP compiler
-
lutra-codegen
Code generation for Lutra
-
rucc-types
The C type system, interned, and layout computation
-
jeff-format
Rust bindings for the jeff exchange format
-
yaml-dsl-compiler
Compiles config-defined YAML DSLs into code: folds layers, expands macros, resolves references, and writes the target language
-
jitvm
a tiny i64-only language with a bytecode interpreter and a hand-rolled x86-64 jit
-
nfst-pmatch
Parser and AST for the pmatch pattern-matching language; reuses nfst-xre operator enums
-
cargo_info_types
Parse the output of
cargo infointo well-typed Rust structures -
gollum-ast
Abstract-Syntax-Tree for the Gollum language
-
provekit_noirc_driver
Noir compiler driver
-
clienthlo
Client HLO (CHLO) dialect for pliron
-
tsrs_core
Core types and utilities for the tsrs TypeScript compiler
-
cargo_pup_lint_impl
Core lint implementations and rustc integration for cargo-pup architectural linting
-
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
-
farmfe_plugin_tree_shake
Tree shake plugin of farm
-
mallubind
Native C-ABI bindings for writing libraries for the Malluscript programming language
-
crush-frontend
Portable Crush language frontend: parser, semantic analyzer, optimizer, and CASM compiler
-
draxl-patch
Structured semantic patch operations over the Draxl model
-
bhc-hir
High-level Intermediate Representation for BHC
-
tpt-eidos-parser
Lexer, AST, and recursive-descent parser for the tpt-eidos language
-
flux-vm-v3
FLUX constraint enforcement bytecode VM — v3 architecture
-
mag_lang
The Mag Language Runtime
-
pepl-types
Shared types for the PEPL compiler: AST nodes, Span, errors
-
kz80_ml
Tiny ML compiler for the Z80 processor with Hindley-Milner type inference
-
cranelift-interpreter
Interpret Cranelift IR
-
ingot-runtime
Reference interpreter for the Ingot Agent IR: executes an agent and enforces its policy and budgets
-
serc-cli
An experimental CPython bytecode compiler, written in Rust
-
bynk-emit
Build orchestration and TypeScript emission for the Bynk compiler
-
clue
C/Rust like programming language that compiles into Lua code
-
snapfire_fsr_lower
The recogniser for SnapFire FSR: reads a TypeScript loader or actions module and lowers each body to the IR, naming the line that stops it
-
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…
-
oak-jasmin
Jasmin Java assembler parser with support for Java bytecode assembly and class file generation
-
stormchaser-dsl
A robust, distributed workflow engine for event-driven and human-triggered workflows
-
harn-glob
Glob pattern matching primitives for the Harn programming language
-
rucc-ir
The SSA IR with block parameters, and its printer, parser and verifier
-
abacus
The mathemagical programming language
-
rucc-safety
The memory safety monitor: check insertion over the IR
-
brink-driver
Pipeline orchestration for the brink ink compiler
-
bytevm
A tiny bytecode virtual machine
-
gleamgen
Gleam generator
-
oak-llvm-ir
High-performance incremental LLVM IR parser for the oak ecosystem with flexible configuration, supporting low-level intermediate representation analysis
-
aplang
A programming language made to aid students who are taking AP Computer Science Principals
-
termaid-mermaid
Mermaid parsing for the Rust termaid terminal renderer
-
nextjs_react_compiler_reactive_scopes
Rust port of the React Compiler, vendored from facebook/react
-
shadewire
core: the material IR (a typed DAG), optimizer, CPU interpreter and reflection
-
llvm-in-rust
Top-level facade crate for the LLVM-in-Rust compiler pipeline
-
bock-parser
Parser for the Bock language, producing AST nodes from token streams
-
hclua
-
sync-ls
Synchronized language service inspired by async-lsp, primarily for tinymist
-
thinkinglanguage-types
ThinkingLanguage — Type system and type checker
-
sixu
Experimental Visual Novel Scripting Language
-
cargo-cardiac
Cargo subcommands for building, running and debugging Rust on CARDIAC
-
maat_stdlib
Standard library sources for the Maat programming language
-
scc-graph
System Context Compiler graph: component/flow compilation, invariants, impact
-
mystsh
Mystical shell parser, formatter, and interpreter with Bash support
-
haloumi-ir-gen
IR generation step of the haloumi lowering pipeline
-
bhc-session
Compiler session state, options, and configuration for BHC
-
tishlang_vm
Bytecode VM for Tish
-
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.
-
fpp_analysis
Semantic analysis passes and type checking for the FPP compiler
-
rajac-ballpit
Experimental sandbox binary for rajac development
-
ruau
Pure Rust implementation of Luau and its analyzer
-
rew-compiler
CoffeeScript/TypeScript compiler for the Rew runtime
-
asg-lang
ASG - A programming language built on Abstract Syntax Graph
-
bappy-script
Gankra's toy compiler
-
surreal-lang
A Rust-inspired language for the BEAM
-
tsz-scanner
TypeScript scanner/tokenizer for the tsz compiler
-
morok-codegen
Backend code generation for the Morok ML compiler
-
tidepool
Compile Haskell effect stacks to Cranelift JIT, drive from Rust
-
ciac-backend-rust
Rust (Axum) code-generation backend for the CIaC compiler
-
graphcal-model-client
Type-safe, unit-aware, Git-friendly reactive programming language for engineering calculations
-
crush-ptx
CASM -> PTX (NVIDIA GPU assembly) emission backend for Crush kernel programs
-
tpt-uir-text
Textual (human-readable) format for TPT-UIR
-
lite_ml
Lightweight markup language compiler
-
kz80_ws
WordStar clone for Z80 - Retro word processor on the RetroShield
-
vize_atelier_sfc
Atelier SFC - The Single File Component workshop for Vize
-
temporaries
Make temporary values useable in a fairly normal style through macros. This nicely wraps the hacks that work around temporaries’ earlier limitations.
-
kz80_calc
VisiCalc-style spreadsheet for Z80 - Retro computing on the RetroShield
-
cargo-util-terminal
Cargo's terminal rendering
-
uv-types
internal component crate of uv
-
midenc-dialect-wasm
Miden IR Wasm Dialect
-
jit-assembler
A multi-architecture JIT assembler library for runtime code generation
-
crush-aotc
Crush AOT compiler: CASM → C source → shared library (.so)
-
libquil-sys
High-level bindings to libquil
-
vibe-ast
Multi-language AST parser with language detection
-
fasb
faceted answer set browser
-
microcad-lang-parse
µcad language syntax lexer and parser
-
souther-binding-runtime
What every Rust binding of a Souther library built by souther-native-compiler runs on: a run's arena, handles, and calls into the library and back
-
intent-implement
AI-powered full implementation generation from IntentLang specifications
-
lift-sim
LIFT compiler static analysis: shape propagation, FLOP counting, memory analysis, noise simulation
-
knok-compile
MLIR lowering and IREE compilation for knok
-
liturgical-calendar
Liturgical calendar engine for the Catholic Novus Ordo — runtime facade
-
python-assembler
Parse and write Python .pyc bytecode
-
alef-backend-magnus
Ruby (Magnus) backend for alef
-
mist-parser
The Mist programming language parser
-
amethyst_geode
Turing Machine Programming Language Interpreter
-
depyler-lambda
AWS Lambda transpilation support for the Depyler Python-to-Rust transpiler
-
melodium-mcp
MCP server exposing Mélodium program validation and reference lookup
-
patchouly
A copy-and-patch JIT framework in Rust
-
oak-php
PHP server-side scripting language parser with support for web development and modern PHP features
-
analisar
A Lua parser for Rust
-
oxc_estree_tokens
A collection of JavaScript tools written in Rust
-
synth-frontend
WASM/WAT parser and module decoder frontend for the Synth compiler
-
rucc-pp
Macro expansion, conditionals, include resolution, and the header cache
-
miden-package-registry-local
Filesystem-backed local package registry for Miden packages
-
assura-diagnostics
Unified diagnostic types for the Assura compiler
-
ling-mir
Ling MIR - Mid-level Intermediate Representation for codegen backends
-
lean-rust-runtime
Runtime of the Rust code generated from Lean by lean-rust
-
sixtyfive
An interpreter for the Sixtyfive programming language, designed for teaching computer science to moths
-
cargo-typify
cargo command to generate Rust code from a JSON Schema
-
metaltile-codegen
Metal Shading Language (MSL) code generator for MetalTile kernels
-
ebnftobnf
A straightforward EBNF to BNF reducer
-
maat_lexer
DFA-based lexer for the Maat programming language
-
brink-db
Incremental project database for inkle's ink narrative scripting language
-
depyler-hir
High-level Intermediate Representation types for the Depyler transpiler
-
ares-suriv
Suriv language lexer, parser, and code generator: surface text to Cordis entry records plus the require coeffect map
-
raic
Raic programming language — compiles to Rust
-
primate
A small DSL for cross-language constants. Write once, generate typed Rust, TypeScript, and Python.
-
cargo-cgp-error-processing
Compiler-free string transforms that make CGP diagnostics readable, driven by the cargo-cgp driver
-
c2rust-transpile
C2Rust transpiler implementation
-
swamp-semantic
semantic types for swamp
-
nucleoid
Declarative logic runtime: statements are tracked in a dependency graph and re-evaluated when what they depend on changes
-
oxc_compat
A collection of JavaScript tools written in Rust
-
polonius-engine
Core definition for the Rust borrow checker
-
rucc-lower
The typed AST to IR walk: SSA construction and ABI-directed lowering
-
valua-lexer
Lua 5.5 tokenizer for the valua transpiler (Lua 5.4 is a supported subset)
-
corvo7
A toy programming language compiler written in Rust
-
rucc-driver
Command line, phase graph and job scheduling for the rucc C compiler
-
chapter3_lexical
A lexical analyzer that returns the tokens you wrote!
-
retrolang
systems programming language compiler for Z80 microprocessors
-
monkeyc
A Monkey programming language implementation in Rust
-
resw
writing RESSA AST parts to a file
-
tsr_printer
TypeScript syntax and text printing for tsr
-
oxur
Lisp dialect that treats Rust as its compilation target and runtime
-
oak-koka
Koka frontend for Oak
-
listen-fire-engine
The listen-fire movement engine: runs a checked movement against a host you supply, natively or over WASM
-
rlx-geo
Exact integer 2D Delaunay triangulation + discrete Voronoi (JFA) for RLX, with per-backend custom ops/kernels
-
monty-alloc
Global allocator enforcing a Monty worker's hard memory ceiling
-
rucc-object
ELF, Mach-O, COFF and wasm object writers
-
repl_lib
creating REPL interpreters
-
etcetera-compiler
A Rust-based compiler project
-
awa5_rs
An AWA5.0 CLI tool written in Rust (btw)
-
qvcm
Register-based bytecode VM with quantum computing functionality
-
tishlang_native
Native code generation backend for Tish (Cranelift / direct compile)
-
lift-hybrid
LIFT compiler hybrid dialect: classical-quantum data encoding and joint gradient computation
-
alder-language-server
Language server for the alder programming language
-
tinywasm-parser
Parser and lowering pipeline for TinyWasm
-
jit-lang
Lower IR to machine code in executable memory and run it now
-
nfst-twolc
Parser and AST for the twolc two-level morphology language; reuses nfst-xre operator enums
-
brink-fmt
Source code formatter for inkle's ink narrative scripting language
-
rusche
A lightweight Scheme interpreter embeddable in Rust applications
-
egglang
The Egg Programming Language From Eloquent JavaScript, but in Rust
-
cme
Checkmate Engine: A statically typed, embeddable scripting language
-
phenotyper-cli
CLI for the Phenotyper compiler
-
astmap-languages
Language parsers and resolvers for astmap (tree-sitter based)
-
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
-
rspack_plugin_rslib
Rslib native plugin
-
brink-analyzer
Cross-file semantic analysis for inkle's ink narrative scripting language
-
erg_compiler
Centimetre: the Erg compiler
-
rust-ascend
Rust Ascend CANN runtime, common-IR compiler and device kernels
-
oak-ocaml
OCaml functional programming language parser with support for modern OCaml features and type system
-
loft-ffi
Helpers for writing loft native extension cdylibs
-
crisp
A small, expressive Lisp-inspired programming language
-
tsr_jsstring
JavaScript strings and byte-preserving source text for tsr
-
idpp
ID++ - Bahasa pemrograman berbahasa Indonesia
-
fift-cli
A CLI for the Fift esoteric language interpreter
-
oxc_react_compiler
oxc integration for the Rust port of React Compiler
-
nassau
A Standard ML implementation with a Cranelift backend
-
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.
-
lower-ir-utils
Helpers for mapping Rust types to Cranelift JIT signatures, lowering call arguments, and reducing module boilerplate
-
lungo
Runtime and facade types for Rust code generated from Lean by lungo-build
-
tpt-augur-mlir
Probabilistic MLIR-compatible dialect, optimization passes, and TPTIR lowering for Augur
-
oak-scala
High-performance incremental Scala parser for the oak ecosystem with flexible configuration, supporting functional programming and JVM ecosystem integration
-
listen-fire
movement language’s parser, checker and engine, and the
listen-firecommand that runs movements locally -
fpp_ast
Abstract syntax tree node definitions and visitor traits for the FPP compiler
-
quickjspp
QuickJS Javascript engine wrapper using quickjs fork named quickjspp
-
rucc-lex
Translation phases 1 to 3, pp-tokens, the fast scanner, the keywords and the constants
-
miden-field-repr
Serialization/deserialization for felt representation
-
tsz-emitter
TypeScript-to-JavaScript emitter and transforms for the tsz compiler
-
rucc-session
The per-compilation session, options and diagnostic sink for the rucc C compiler
-
spade-lang
The Spade compiler
-
bock-codegen
Multi-target code generation for Bock — JS, TS, Python, Rust, Go
-
assura-ast
Assura AST types (Spanned, Expr, Decl, etc.) - the compiler IR
-
depyler-quality
Quality gates and metrics for Depyler
-
ab-riscv-interpreter
Composable and generic RISC-V interpreter
-
dig2memory
AST index and dependency graph server for code intelligence
-
lu
embedding Luau
-
splik
programming language identifier kit
-
midenc-frontend-masm
MASM disassembler frontend for the Miden compiler
-
deed-ast
Syntax tree for the Deed language
-
oak-r
R statistical programming language parser with support for data analysis, statistical computing, and graphics
-
mlua-crc16
A Rust-native implementation of LuaRocks youlu/luacrc16 for mlua
-
metaltile
Rust DSL for writing Apple Metal GPU kernels — write once, run fast on Apple Silicon
-
noxid-codegen-server-js
The codegen-server-js component of the Noxid compiler
-
naga-rust-embed
Translates WGSL shader code to Rust embedded in your Rust code
-
nmp-feed-session
Shared feed-session compiler for NMP runtimes
-
karaka-core
Karaka language core: lexer, parser, evaluator
-
vpratt
absolute zenith of pratt parsing
-
ironwork-syntax
ironwork for COBOL: fixed-format source reader, lexer and parser
-
rlx-umap
Parametric UMAP on RLX — full fit/transform API and k-NN building blocks
-
unseemly
A typed macro language
-
netsblox-ast
parsing NetsBlox project files into an AST for use in code generation
-
wmlua
-
rucc-sema
Type checking, conversions, initialization, constant evaluation, and the typed AST
-
shavenscript
Lightweight programming language made in rust with support for array and basic operations
-
wesl-cli
CLI for the WESL compiler
-
bynk-ide
The IDE analysis surface of the Bynk compiler: non-bailing single-file and project diagnostics, and the editor queries a language server consumes
-
ilm
A fun programming language with Islamic terminology
-
gen-nix
gen — typed Nix AST + pretty-printer + per-crate (crate2nix shape) derivation renderer. Every Nix construct the substrate emits is a typed
NixValuerendered through one canonical pretty-printer… -
tl-lsp
Language Server Protocol implementation for ThinkingLanguage
-
pfcl-interpreter
Tree-walking interpreter for PFCL — pure functions, List<Command> effects
-
bock-lexer
Tokenizer for the Bock language
-
duck-diag
Generic diagnostic engine for building rich error reporting into any tool
-
modu
A fast and simple turning-complete interpreted language
-
argus-lib
Trait debugger analysis for IDE interactions
-
misty-parser
Parser code required by the Misty Compiler
-
tsz-checker
TypeScript type checker for the tsz compiler
-
hozo_native
Hozo IR to React Native primitive/StyleSheet lowering (Native backend)
-
oak-javadoc
Javadoc documentation language parser with support for API documentation generation and code analysis
-
nl_opt
Verilog compiler driver for running safety-net passes
-
rucc-diag
Diagnostics, spans and source maps for the rucc C compiler
-
lexit
A Lexical Analysis tool for defining a language and lexing it into tokens
-
liteml
一个用 Rust 实现的轻量级标记语言编译器。
-
t-repl
Shared REPL infrastructure for T and Ty compilers
-
renyi_syntax
Lexer, parser and formatter for the Renyi programming language
-
symjit-bridge
a bridge bwtween Symjit compiler and Symbolica CAS
-
relon-cap
Leaf crate holding Relon's canonical capability data types (CapabilityBit / NativeFnGate / Capabilities)
-
mangle-driver
Driver for Mangle compilation pipeline
-
lamina-codegen
Codegen utilities for Lamina (register allocation, ABI, frame management)
-
assura-smt
SMT-based verification for Assura contracts via Z3
-
draxl-rust
Rust language adapter for Draxl
-
scala
A experimental Scala interpreter written in Rust: lexer, parser, type inference, and tree-walking evaluation with a REPL
-
oxc_jsdoc
A collection of JavaScript tools written in Rust
-
voce-compiler-wasm
Voce IR WASM compiler — compiles state machines and compute nodes to WebAssembly
-
ironwork-exec
ironwork for COBOL: an interpreter over EBCDIC storage
-
rustc_codegen_spirv-types
SPIR-V backend types shared between rustc_codegen_spirv and spirv-builder
-
struo-cli
Command-line interface for Struo
-
rucc-opt
The pass manager, the acyclic e-graph, the rewrite rules and the analyses
-
xasm-rs
generating linux 32/64 bit assembly easily
-
spade-typeinference
Helper crate for https://spade-lang.org/
-
mist-analyzer
The Mist programming language Analyzer LSP
-
koto_runtime
The runtime used by the Koto programming language
-
tsr_compiler
TypeScript program loading, diagnostics and compiler orchestration for tsr
-
brink-codegen-json
JSON codegen backend: LIR → ink.json format
-
codonsplice-core
CodonSplice engine — SpliceQL bytecode compiler, VM, and (Phase 4) cnvlens-core bridge
-
lep
Mini language for interactive consoles, featuring small code footprint
-
koopa
generating/parsing/optimizing Koopa IR
-
steel-rc
Biased reference counting implementation for steel
-
luck_lexer
Single-pass lexer for Lua 5.1-5.5 and Luau
-
alef-snippets
Reusable documentation snippet discovery and validation for Alef
-
lisette-syntax
Little language inspired by Rust that compiles to Go
-
tspc
TypeSpec compiler CLI — convert .tsp files to JSON, YAML, OpenAPI and more
-
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.
-
assura-config
Project configuration and output mode types for the Assura compiler
-
rucc-cost
The cost model: what an operation costs on a target, and every tuning constant
-
treeedbgen
Parse node-types.json from a tree-sitter grammar
-
rucc-wasm
The WebAssembly back end: selection, structured control flow and the object
-
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.
-
rlx-gpu-dispatch
Shape-keyed GPU kernel-variant dispatch table + tile parameter space shared by every RLX GPU backend
-
brief-core
Compiler library for the Brief markup language: lexer, parser, AST, HTML/LLM emitters, formatter, and Markdown-to-Brief converter
-
uiua_parser
Uiua parser implementation
-
pepl-compiler
PEPL compiler: orchestrates the full compilation pipeline
-
rucc-codegen
Instruction selection, scheduling, block layout, frames and prologue emission
-
varyk-syntax
Lexer, parser, and AST for Varyk, a programming language for backend services that compiles to Rust
-
monty-cli
A sandboxed, snapshotable Python interpreter written in Rust
-
catallaxy-runtime
Object model, NaN-boxed values and ownership states for the Catallaxy language
-
mec
mruby/edge compiler cli endpoint
-
voce-compiler-ios
Voce IR iOS compiler — compiles IR to SwiftUI code with VoiceOver accessibility
-
vulkane-spirv-emit
The SPIR-V compute-shader emitter for Unpopped: IR to a binary SPIR-V module (GLSL.std.450, storage-buffer blocks, a LocalSize entry), carried as the kernel's word stream. Vulkane owns SPIR-V.
-
hiraku-script
Hiraku visual-novel scripting language
-
brink-codegen-inkb
Bytecode codegen backend: LIR → StoryData (inkb format)
-
brink-converter
Converts inklecate .ink.json to brink .inkb format
-
bock-fmt
Source code formatter for the Bock language
-
mmi-cli
CLI and compiler for Mastermind, the BF compiler
-
bynk-fmt
The formatter for the Bynk language
-
spliceql
query language frontend for CodonSplice — lexer, parser, AST, bytecode compiler
-
steel-doc
Document generation for steel
-
obscura-core
Core obfuscation engine: AST transforms, options, pipeline. Rust port of javascript-obfuscator.
-
wolfpack-go
The Go backend of the wolfpack compiler. Internal part of wolfpack-lang, not a stable API
-
fugue-sleighc
Wrapper around Ghidra's SLEIGH specification compiler
-
valua-codegen
Lua 5.1 code emitter for the valua transpiler
-
smelt-codegen-rust
Rust source-code generation from Smelt MIR
-
fusabi-frontend
Frontend (parser, compiler) for Fusabi language
-
vyre-driver
Driver layer: registry, runtime, pipeline, routing, diagnostics. Substrate-agnostic backend machinery. Part of the vyre GPU compiler.
-
bynk-lsp
Language Server for the Bynk language
-
blue-lang-bidama
bidama — a blue package, and posture resolution: join the floors, check against the root ceiling
-
wesley-emit-typescript
TypeScript syntax-model emitter for Wesley IR
-
wright
programming language compiler and tooling
-
pielang
RIIR Pie, a dependent type language
-
rocalang
A contractual language for the AI era
-
moonjuice-transpiler-luau
Transpile MoonJuice AST nodes to the Luau scripting language
-
brink-json
Parser for inklecate .ink.json output format
-
celox-analysis
IR-independent compiler analyses used by Celox
-
maat_air
CPU constraint system (AIR) for the Maat programming language
-
sap-cli
The command line interface for the SAP programming language
-
rns-lang
RNS language parser, compiler, and assembler library for the Lagertha VM project
-
ironwork-numeric
ironwork for COBOL: IBM Enterprise COBOL numeric semantics under ARITH, TRUNC, NUMPROC and CODEPAGE
-
brik64-bir
BRIK-64 BIR bytecode runtime — embed the BIR interpreter in any Rust project
-
assura-runtime
Runtime contract monitoring for Assura-generated Rust code
-
onion-vm
Virtual machine runtime for the Onion programming language with async execution and garbage collection
-
tsz-lowering
AST-to-type lowering bridge for tsz
-
valua-core
Orchestrates the full valua transpile pipeline (lex → parse → transform → codegen)
-
just-engine
A ground-up ES6 JavaScript engine with tree-walking interpreter, bytecode VMs, and Cranelift JIT compiler
-
prima-jit
Prima cranelift JIT for numeric hot paths (spec §19.2)
-
bock-interp
Tree-walking interpreter for the Bock language, used by
bock runand tests -
haloumi-synthesis
Synthesis step of the haloumi lowering pipeline
-
egglog-bridge
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.
-
vize_oxc_parser
Vize's fork of the Oxc parser with admission and observation APIs
-
lexerus
annotated lexer
-
spl
Stack Pogramming Language: A simple, concise scripting language
-
llvmkit-asmparser
Lexer and parser for LLVM textual IR (.ll), mirroring llvm/lib/AsmParser
-
crush-cast
Crush Abstract Syntax Tree (CAST) - Stable Intermediate Representation
-
nova-hir
The Nova language's high-level IR (internal to the nova toolchain)
-
reqlang-expr
A tiny (bytecode compiled, stack VM interpreted) expression language for reqlang's templating engine
-
llvm-in-rust-ir
Core LLVM-inspired intermediate representation data structures and builders for LLVM-in-Rust
-
voce-adapter-vercel
Voce IR Vercel deployment adapter — Build Output API v3
-
beadie-backend
JitBackend trait, BackendAdapter, BoundBead, and TieredAdapter
-
rucc-unpack
Reads the container formats Microsoft's Windows SDK payloads arrive in, deflate and zip and cabinet and compound file, and the gzip and tar of a sysroot, for the rucc C compiler
-
tsz-lsp
Language Server Protocol implementation for the tsz compiler
-
rucc-parse
Recursive descent with a Pratt expression parser, declarators, and error recovery
-
tabulon
A high-performance, JIT-compiled expression evaluation engine using Cranelift
-
pop65
A 6502 assembler
-
omg_runtime
The OMG language runtime and virtual machine, providing bytecode execution, REPL, and built-in functions
-
rucc-ast
The arena-allocated AST and its printer
-
hvm1
A massively parallel functional runtime
-
mysz-core
The main compiler for the Mysz language project
-
lamina-ras
ras - as/GAS alternative. Cross-platform assembler: assembly source (.s) to relocatable object files (.o). Used by Lamina, usable standalone.
-
rucc-sysroot
Sysroot layout, header search paths and link lines for rucc, computed from the target and never from the host
-
svod-codegen
Backend code generation for the Svod ML compiler
-
hugr-persistent
Persistent IR structure for Quantinuum's HUGR
-
bitloom-firrtl
FrozenHir ↔ FIRRTL 6.0.0 text for Bitloom (crates.io: bitloom-firrtl). Unrelated to samitbasu/rhdl.
-
leo-retriever
A retriever for the Leo programming language
-
wolfpack-ir
The intermediate representation of wolfpack and the lowering into it. Internal part of wolfpack-lang, not a stable API
-
oxide_lisp
lisp interpreter engine in Rust
-
catallaxy-stdlib
Native standard library for the Catallaxy language
-
mech-compare
Comparison library for the Mech language
-
stak-util
Stak Scheme
-
assura-fmt
Source code formatter for the Assura contract language
-
jzero-codegen
TAC and bytecode code generation for the Jzero compiler
-
ironwork-compile
ironwork for COBOL: the compiler that checks a parsed program and lays out its storage as IBM does
-
melody_compiler
The Melody language compiler
-
rucc-mir
The machine IR, still in SSA, and its printer and parser
-
koto_parser
The parser used by the Koto programming language
-
morok-runtime
Kernel execution runtime for the Morok ML compiler
-
rucc-rules
The rewrite and lowering rule DSL compiler for the rucc C compiler
-
hozo_web
Hozo IR to DOM/CSS/ARIA lowering (Web backend)
-
sandy-seatbelt
Typed macOS Seatbelt policy compiler and native boundary for Sandy
-
orco
A compiler backend interface
-
bitloom-viz
HIR HTML dump / wave viz for Bitloom (crates.io: bitloom-viz; FR38). Unrelated to samitbasu/rhdl.
-
coda-runtime
the runtime for coda, an experimental scripting language
-
ternlang-edu
The RFI-IRFOS Educational Cartel. Standardized curriculum tools for ternary literacy.
-
oak-racket
Hand-written Racket frontend
-
typst-macros
Proc-macros for Typst
-
abrase
language
-
clr-assembler
Modern CLR assembler for x64 and x86 instruction sets - strongly typed, object-oriented, zero-dependency core
-
oxabl_ast
AST node definitions for the Oxabl ABL parser
-
constraint-compiler
Deterministic projection-to-inference graph compiler for the recursive inference kernel
-
rucc-verify
SMT verification of the rucc rewrite and lowering rule set
-
umjunsik
Language compiler targeting Lamina IR
-
cccc-rb
Ruby (ruby-prism) adapter that lowers source into the cccc-core complexity IR
-
tpt-eidos-erasure
Proof-term erasure for tpt-eidos: strip refinement witnesses from a kernel-checked module, producing a computational-core IR
-
b3
port of B3 WebKit codegen backend
-
cargo-slicer
Speed up Rust release builds by skipping codegen for unreachable functions and processing of other skippable items
-
tsr_scanner
TypeScript and JavaScript lexical scanning for tsr
-
libket
Runtime library for the Ket programming language
-
hmacro
macro preprocessor
-
yog-script-java
Yog Script compiled to Java: a checked source written as one Java class (its types nested), for javac to make the bytecode the hosts load
-
fuxth
A small Forth for the shell: shell-friendly words, typed values, and an evaluator that pauses for its host
-
csw-cli
Command-line interface for the Categorical Semantics Workbench
-
ironwork-zarch
ironwork for COBOL: z/Architecture data semantics: EBCDIC code pages, decimal instructions, hexadecimal floating point
-
tremor-script
Tremor Script Interpreter
-
miden-assembly-syntax-cst
Lossless concrete syntax tree support for the Miden Assembly language
-
sim-codec-python
Bounded, lossless Python 3.14 source frontend for SIM
-
pliron-circt
An MLIR-based compiler infrastructure spanning multiple abstraction levels of hardware representation, transformation, and RTL generation
-
depinfo
parser for Rust
-
haloumi-lowering
Core traits for enabling types to integrate with the codegen module
-
oak-von
Valkyrie language parser with support for modern Valkyrie syntax and features
-
flux-ast
Universal Constraint AST — single source of truth for constraint semantics across all representations
-
morok-dtype
Type system for the Morok ML compiler
-
rucc-headers
Derives a multi-version libc header tree from real installed header sets, for the rucc C compiler
-
arithma
An easy to use, domain-specific programming language for numeric mathematics
-
pydis
Python 2.7 bytecode disassembler
-
strontium
A register-based bytecode machine for statically and dynamically typed programming languages
-
catallaxy-compiler
Parser, type checker and bytecode compiler for the Catallaxy language
-
php-wasm
WebAssembly bindings for the PHP parser and printer
-
typescript-types
Type definitions for TypeScript compiler
-
wolfpack-ast
The syntax tree of wolfpack. Internal part of wolfpack-lang, not a stable API
-
horkos
Cloud infrastructure language where insecure code won't compile
-
oak-voml
Valkyrie language parser with support for modern Valkyrie syntax and features
-
stak-macro-util
Macro utilities for Stak Scheme
-
airl-compile
Cranelift JIT compiler and WASM backend for AIRL IR
-
wolfpack-rs
backend of the wolfpack compiler. Internal part of wolfpack-lang, not a stable API
-
tl-interpreter
Tree-walking interpreter for ThinkingLanguage (Phase 0)
-
tsr_ls
Language service conversions and queries for tsr
-
lua2hcb_compiler
A compiler for Lua-like scripts to HCB
-
tsz-solver
TypeScript type solver for the tsz compiler
-
light_ranged_integers
Ranged integers for stable Rust compiler, zero-dependencies and no unsafe code
-
lamina-mir
MIR (Machine Intermediate Representation) type definitions for Lamina
-
ken
Compiler, tooling, and language server for the Ken programming language
-
oak-mojo
Mojo frontend for Oak
-
bliplib
The Bizarre Language for Intermodulation Programming (BLIP)
-
lua-parse
omniLua’s Lua parser — internal crate; depend on
omnilua -
lau-agent-runtime
Self-compiling agent runtime — agents build their own interpreters, compilers, and runtimes
-
espy
a functional, embeddable scripting language
-
wolfpack-lexer
The lexer of wolfpack. Internal part of wolfpack-lang, not a stable API
-
nessa-language
An extensible programming language with a strong type system
-
telltale-machine
Protocol machine for choreographic session type protocols
-
ling-animation
Anima — Ling's unified animation system: one rig, any target, any temperament (organic 灵 ↔ mechanical 机)
-
ergotree-ir
ErgoTree IR, serialization
-
voce-adapter-static
Voce IR static deployment adapter — plain dist/ folder output
-
swamp-parser
Parses Swamp programming language source code into an Abstract Syntax Tree (AST) defined in the
swamp-astcrate, using the pest parsing library -
tsr_pseudochecker
Syntax-based type builder support for tsr
-
voce-compiler-android
Voce IR Android compiler — compiles IR to Jetpack Compose with TalkBack accessibility
-
draxl-parser
Language-dispatch facade for Draxl parsing
-
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.
-
wolfpack-span
Source files, spans and line positions of the wolfpack compiler. Internal part of wolfpack-lang, not a stable API
-
lang-interpreter
reimplementation of the Standard Lang interpreter
-
rajac-lexer
Java lexer for the rajac compiler
-
noxid-compiler-core
The Noxid compiler pipeline shared by every front end
-
tapir-bf
Tapir is a moderately useful Brainfuck interpreter
-
otter-runtime
JavaScriptCore runtime for otter - TypeScript/JavaScript execution engine
-
draxl-validate
Structural validation for Draxl source files
-
nextjs_react_compiler_optimization
Rust port of the React Compiler, vendored from facebook/react
-
oak-rst
High-performance incremental reStructuredText parser for the oak ecosystem
-
claw10-icvs
ICVS compiler wrapper for Claw10 OS
-
wrecc
A x86_64 C99 compiler written from scratch
-
nextjs_react_compiler_validation
Rust port of the React Compiler, vendored from facebook/react
-
bynk-ts
The TypeScript tree and printer of the Bynk compiler: emission builds nodes, and this printer is the only code that writes emitted text
-
ruau-vm
The Ruau VM: a pure-Rust, async, sandboxed executor for Luau bytecode
-
wolfpack-ts
The TypeScript backend of the wolfpack compiler. Internal part of wolfpack-lang, not a stable API
-
llvmkit
Rust reimplementation of LLVM IR APIs
-
kz80_prolog
Prolog compiler for Z80 - Logic programming on the RetroShield
-
fuellite
Fuel and byte-budget primitives: mechanical termination and output bounds. One shared budget across all composition, so fractal recursion terminates by construction.
-
ironwork-jcl
ironwork for COBOL: a reader for z/OS job control language
-
mil_machines
Non-neural state machines compiled to stateful MIL programs: Aho-Corasick automata, EWMA scorers, mutable memory banks. Silicon a regex can live on.
-
depyler-mcp
Model Context Protocol integration for Depyler
-
parlex-calc
Parlex example: simple calculator
-
pflow-dsl
S-expression DSL for defining token model schemas
-
wolfpack-project
Wolfpack projects: the manifest wolfpack.toml and the project layout. Internal part of wolfpack-lang, not a stable API
-
mnn-src
Pristine MNN sources and native build support
-
epics-seq-rs
Rust port of the EPICS sequencer: the run-time (seq, pv) and, under the snc feature, the SNL compiler that turns an unchanged .st program into Rust at build time
-
ad-astra
Embeddable scripting language platform Ad Astra. Main Crate.
-
chalkline-core
Core library, spec parser, recon engine, ambiguity griller, and DAG compiler for chalkline
-
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.
-
tsr_module
TypeScript module resolution for tsr
-
tishlang_cranelift_runtime
Runtime for Cranelift-compiled Tish bytecode
-
provekit_noirc_frontend
Frontend of the Noir compiler
-
ellie_engine
Why ellie? Ellie is a type-safe programing language that runs on embedded and sandboxed environments
-
ezno-checker
A fast and correct TypeScript type checker with additional experiments
-
mirascript
Embeddable Rust compiler and virtual machine for MiraScript
-
erebus
A CLI message generation library
-
llvm-in-rust-target-x86
x86-64 target backend for LLVM-in-Rust code generation
-
tupa-lint
Linter for TupaLang source code
-
tinymist-project
Project model of typst for tinymist
-
makepad-live-compiler
Makepad platform live DSL compiler
-
koto_bytecode
The bytecode compiler used by the Koto programming language
-
draxl-printer
Language-dispatch facade for Draxl rendering
-
llvm-in-rust-target-riscv
RISC-V target backend for LLVM-in-Rust code generation
-
wave-compiler
WAVE compiler - compiles high-level kernel code to WAVE ISA binaries
-
deq-runtime
deq: Real-time Quantum Error Correction Decoding System
-
provekit_noirc_arena
Arena allocation utilities for the Noir compiler
-
pfcl-typechecker
Hindley-Milner type inference for PFCL's content-addressed function catalog
-
mech
programming language for building reactive systems like robots, games, and animations
-
mathcompile
High-performance symbolic mathematics with final tagless design, egglog optimization, and Rust hot-loading compilation
-
llvm-in-rust-transforms
Optimization and transformation passes for LLVM-in-Rust IR
-
mist-api
The Mist programming language module system
-
spec-checker
Property-based and runtime-gate checker for Lex specs
-
cambridge-asm
Run pseudoassembly from Cambridge International syllabus 9618
-
zia
Interpreter Library for the Zia Programming Language
-
lisette-stdlib
Little language inspired by Rust that compiles to Go
-
jasm-assembler
Modern assembler for JVM instruction set - strongly typed, object-oriented, zero-dependency core
-
rs_calc
A small calculator made using Rust
-
llvm-in-rust-analysis
Control-flow, call-graph, dominance, loop, and use-def analyses for LLVM-in-Rust IR
-
relon-eval-api
Public types and Evaluator trait shared across Relon evaluation backends
-
ironwork-oracle
ironwork for COBOL: test programs whose results settle the model's assumptions against a real compiler
-
intent-gen
Natural language to IntentLang spec generation via LLM (Layer 0)
-
mininter
A MiniScript compiler/interpreter, writen in pure rust, with easy to use API
-
recc
A C compiler with graphs
-
dalbit
A Luau-to-Lua transpiler
-
lisette-format
Little language inspired by Rust that compiles to Go
-
rucc-legalize
IR to IR rewrites into the operations that a back end has
-
treeedb-java
Generate Datalog facts from Java source code
-
amble_script
Authoring-focused DSL, parser, and compiler that produces Amble engine WorldDef data
-
llvm-in-rust-target-arm
AArch64 target backend for LLVM-in-Rust code generation
-
llvm-in-rust-ir-parser
Lexer and parser for LLVM textual IR into LLVM-in-Rust data structures
-
lua-cli
The lua-rs command-line interpreter: Lua 5.4 in safe Rust
-
spade-diagnostics
Helper crate for https://spade-lang.org/
-
maid-lang
Maid Programming Language
-
ana-lang
A small interpreted language
-
phoenix-lang
fast programming language
-
w16-lib
Библиотека для использования W16
-
ast-demangle
Parses mangled names and produces structured results
-
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…
-
espy-tail
espy's bytecode compiler
-
edlc_doc_db
SQLite storage layer for EDL documentation
-
rucc-wasm-link
A static linker for wasm inside the rucc C compiler, for a host that cannot start wasm-ld
-
bac
Rust bindings for the BAC compiler backend
-
genotype_core
Genotype language core crate
-
ra-jit-cfg
Fork of rust-analyzer's cfg crate, used by ra-jit
-
rustleaf
programming language interpreter written in Rust
-
omnilua-cli
Every Lua, everywhere — pure-Rust Lua 5.1–5.5, suite-passing, LuaRocks-compatible, wasm-ready
-
bynkc
Final release: bynkc is now bynk. Install the bynk crate instead (cargo install bynk); this crate only forwards to it.
-
eqiora-lang
Eqiora L1: lossless lexer, parser AST, formatter, and source diagnostics
-
koto_memory
Memory management utilities used by the Koto programming language
-
lumic
Lumi compiler
-
wolfpack-own
The ownership checker of wolfpack. Internal part of wolfpack-lang, not a stable API
-
runmat-snapshot
High-performance snapshot creator for preloading RunMat standard library
-
tket2-hseries
TKET2 tool for preparing and validating
Hugrs for compilation targeting Quantinuum H-series quantum computers -
espr
EXPRESS Language compiler
-
mathic
A compiler with builtin support of symbolic operations, built with LLVM/MLIR
-
makepad-live-tokenizer
Makepad platform live DSL tokenizer
-
bloq_lassynth
Optional Rust port of Python LaSsynth for small lattice-surgery layout searches
-
cmtc
compiler providing cmtir-based passes to generate backends including FIRRTL, SystemVerilog and simulators
-
wolfpack-vm
The bytecode virtual machine of the wolfpack compiler. Internal part of wolfpack-lang, not a stable API
-
brainfoamkit
An interpreter for the brainf*** language
-
tsr_lsp
Language server session and project dispatch for tsr
-
bock-lsp
Language Server Protocol implementation for the Bock language
-
wolfpack-fmt
The formatter of wolfpack source, wolf fmt. Internal part of wolfpack-lang, not a stable API
-
ccarp
(trans)Compile C And Rust Partially
-
axonml-jit
JIT compilation for Axonml tensor operations
-
tsr_autoimport
Auto-import indexes and import edits for tsr
-
tinymist-task
Task model of typst for tinymist
-
rucc-archive
Writes the ar archives a linker reads as static libraries, with the symbol index in them and nothing that varies between two runs, for the rucc C compiler
-
kohebi-testing
Three-way differential harness, fuzzers, and stress modes
-
rsjsonnet-lang
A Jsonnet evaluation library
-
catallaxy-gc
Parallel stop-the-world mark-sweep garbage collector for the Catallaxy language
-
alef-codegen
Shared codegen utilities for the alef polyglot binding generator
-
assura-stdlib
Assura standard library contracts and prelude types
-
kohebi-parse
Lexer, parser, and CPython-compatible AST for kohebi
-
catallaxy-vm
Register-based bytecode interpreter for the Catallaxy language
-
rucc-gnu
The GNU compatibility surface: features.toml, attributes, builtins, pragmas
-
swiftsc-cli
Command-line interface for SwiftSC-Lang compiler
-
oak-vbnet
VB.NET parser for the Oaks framework
-
rajac-types
Type system data structures for the rajac compiler
-
lisp-rs
Lisp interpreter in Rust
-
lumen-provider-fs
The AI-Native Programming Language
-
destack
Rust client for Destack
-
moore
A compiler for hardware description languages
-
umpl
meme language that is a mix of c like languages and lisp like languages
-
plexus-ui-compiler
The plexus-ui component compiler — a component's source to the contract's view tree and Rhai handlers, natively and in wasm
-
sql-ast
A lean sql AST and parser
-
mech-io
Input/output library for the Mech language
-
haloumi
Entrypoint crate for the Haloumi framework
-
llts
TypeScript to native compiler via LLVM
-
depyler-corpus
Deterministic scientific corpus analysis for Python-to-Rust transpilation quality measurement
-
leap-lang
Leap language parser
-
llvm-in-rust-bitcode
Compact bitcode reader and writer for LLVM-in-Rust IR modules
-
grove-ast
Abstract syntax tree types and balanced ternary primitives for the Grove compiler ecosystem
-
mutica-semantic
Semantic analysis library for the Mutica programming language
-
lutra-interpreter
Bytecode interpreter for Lutra programs
-
renyi_package
Packages of Renyi programs: the manifest, the lockfile, versions, the registry layout and the resolution of imports (decision AC1)
-
graphcal-eval
Type-safe, unit-aware, Git-friendly reactive programming language for engineering calculations
-
steel-interpreter
Steel repl and command line interface
-
cuda-forth
Minimal Forth agent language
-
zerodds-idl-csharp
No longer part of ZeroDDS. Replaced in 1.0.0-rc.7 by zerodds-idlc generate --lang c#: the C# mapping is a set of rules in zerodds-lang-rules over the common IDL model.
-
dolang-bytecode
Bytecode format and verification for the Do language
-
tinylang-v2
TinyLang compiler, verified bytecode runtime, adaptive JIT, and C ABI
-
peepmatic
DSL and compiler for generating peephole optimizers
-
verbena
Scripting language
-
specl-syntax
Lexer, parser, and AST for the Specl specification language
-
wscript-cli
CLI runner for Wscript
-
maat_runtime
Runtime value system for the Maat programming language
-
vxc
A heterogeneous-systems programming language that puts placement and reachability in the type system
-
voce-adapter-netlify
Voce IR Netlify deployment adapter
-
backyard-parser
Parse PHP code to AST node
-
icss-lang
Indented CSS parser and compiler
-
tygr
Define your grammar once as Rust types and get a parser, printer, and EBNF presentation for free
-
brink-ir
Intermediate representations for inkle's ink narrative scripting language
-
bock-build
Build pipeline for Bock projects, coordinating parse, check, codegen, and target compilation
-
flowistry
Modular information flow analysis
-
lexlite
Byte-cursor lexer kit for purpose-sized languages: comments, idents, digits, and UTF-8-safe char decode by construction
-
russl_expand
The expansion behind russl!, for a framework's own shader macro with its extension
-
maat_prover
Zero knowledge STARK prover and verifier for the Maat programming language
-
parselite
Recursive-descent parser harness with the depth guard baked in: deeply nested input returns a diagnostic, never a stack overflow
-
stacky
Programming Language
-
treeedb-javascript
Generate Datalog facts from JavaScript source code
-
stator_jse
Stator JavaScript engine core — parser, bytecode compiler, Maglev JIT, interpreter, GC
-
voce-adapter-cloudflare
Voce IR Cloudflare Pages deployment adapter
-
sap-parser
The parser crate for the SAP programming language
-
graphcal-lsp
Language Server Protocol implementation for Graphcal
-
ironmind
A Brainf*ck interpreter and code execution visualizer built in Rust
-
treeedb-csharp
Generate Datalog facts from C# source code
-
treeedb-c
Generate Datalog facts from C source code
-
rucc-lto
Module merging, summaries and Thin LTO
-
swamp-vm-disasm
disassembler for the opcodes in the swamp vm
-
rvsdg
Type-safe standalone implementation of the RVSDG IR with automatic Phi transformation
-
vyre-emit-naga
Naga IR emitter for vyre KernelDescriptor. Produces wgpu-compatible compute shaders.
-
tinymist-query
Language queries for tinymist
-
bock-vocab
Self-describing language vocabulary emitter for Bock — keywords, errors, prelude, stdlib, annotations
-
rajac-diagnostics
Diagnostic reporting infrastructure for rajac
-
edlc_analysis
Code analysis utils EDL compiler
-
pcre2-sys
Low level bindings to PCRE2
-
pycc-rs
Pin1Yin1 compiler rust implementation
-
molt-forked
Embeddable TCL interpreter for Rust applications (personal forked)
-
rever
Interpreter and REPL for the Rever language
-
jrsonnet-evaluator
jsonnet interpreter
-
tpt-telos-router
Context router that classifies tpt-telos modules to Rust or Go backends
-
rajac-symbols
Symbol tables and semantic symbol data for rajac
-
graphcal-compiler
Type-safe, unit-aware, Git-friendly reactive programming language for engineering calculations
-
bynk-std
The Bynk standard library’s first-party sources as data: the
bynksurface, the Bynk-written commons, thebynk.cloudflareplatform adapter, and their per-platform TypeScript bindings -
rajac-ast
Abstract syntax tree definitions for the rajac Java compiler
-
knave-expand
The reading, scoping and expansion stages of knave
-
kaledis_dalbit
A fork of a Luau-to-Lua transpiler based on darklua to use for kaledis
-
draxl-agent
Internal agent-edit backend and MCP server for Draxl
-
netidx-bscript
An incremental scripting language for netidx
-
circomspect-program-structure
Support crate for the Circomspect static analyzer
-
runmat-kernel
Jupyter kernel implementation for RunMat using ZeroMQ and the Jupyter protocol
-
sandkiste
Language independent scripting language sandbox API
-
dolang-compile
Parser, resolver, and bytecode compiler for the Do language
-
rex-parser
Rex: A strongly-typed, pure, implicitly parallel functional programming language
-
koto_regex
A Koto library for working with regular expressions
-
kernite
Kernels written as instructions over variables, compiled to assembly that changes only when they do
-
sleigh-compiler
Rust bindings for the Ghidra SLEIGH compiler. Used to compile processor .slaspec files into .sla files
-
python-mod
Proc-macros that compile Python modules into Rust at build time (the Rython toolchain)
-
mailang-bytecode
Bytecode definitions for MaìLang (no_std capable)
-
noxid-design-ir
The design-ir component of the Noxid compiler
-
rajac-token
Token definitions for the rajac Java frontend
-
souper-ir
manipulating Souper IR
-
fomoscript
Toy scripting language
-
sabiruby-cli
The
sabirubycommand: run Ruby source and mruby 4.1 bytecode on the SabiRuby VM, with the switches of the reference mruby, and compile like mrbc -
vast
Verilog AST library
-
wolfpack-driver
The in-memory compiler pipeline of wolfpack. Internal part of wolfpack-lang, not a stable API
-
bynk-render
Final release: superseded by bynk-driver (its
rendermodule). Diagnostic rendering for the Bynk compiler: ariadne human output and the short line form. -
graphcal-project
Type-safe, unit-aware, Git-friendly reactive programming language for engineering calculations
-
phoron_asm
A Jasmin-compatible Assembler for the JVM
-
crane-win64
A high-performance direct-to-binary compiler backend with built-in IR parser
-
parsey
parser-generator framework
-
tinymist-render
Rendering features for tinymist
-
p2sh
Programming language interpreter
-
ruau-runner
Bounded multi-tenant request runner for Ruau
-
graphcal-model-protocol
Type-safe, unit-aware, Git-friendly reactive programming language for engineering calculations
-
jinko
safe, small and fast programming language with Rust interoperability
-
static-reflect
Static type information, giving a form of compile-time reflection
-
shader-slang
Rust bindings for the Slang shader language compiler
-
aarchmrs-instructions
AARCHMRS-generated ARM instructions functions
-
bock-ai
AI provider interface for Bock's AI-native code generation pipeline (Generate, Repair, Optimize, Select)
-
qalam
Interpreter for the Qalam programming language. Qalam is a dead-simple, Urdu inspired, interpreted programming langauge.
-
panproto-jit
LLVM JIT compilation of panproto expressions for accelerated data migration
-
airl-ir
Core IR data structures for AIRL (AI-native Intermediate Representation Language)
-
backyard-generator
Convert AST node back to PHP code
-
tishlang_cranelift
Bytecode to native via Cranelift
-
xee-xpath-ast
XPath parser and AST implementation
-
llvm-lib
LLVM library with safe and flexibility in mind, without over complexity based on LLVM-C API
-
ringkernel-wgpu-codegen
WGSL code generation from Rust DSL for RingKernel
-
fastc-lsp
Language Server Protocol implementation for FastC
-
wolfpack-std
The standard library of wolfpack, as wolfpack source. Internal part of wolfpack-lang, not a stable API
-
leo-interpreter
Interpreter for the Leo programming language
-
tinymist-l10n
Localization support for tinymist and typst
-
jzero-semantic
Semantic analysis and type checking for the Jzero compiler
-
swipl
A high-level library for building SWI-Prolog extensions and embedding SWI-Prolog in rust applications
-
tatara-eval
Optimized in-memory Lisp interpreter for tatara — evaluates Sexp to Value, produces typed Derivations, composes with tatara-nix realizers
-
filter-expr
parsing the filter expression
-
tl-gpu
GPU tensor compute for ThinkingLanguage via wgpu
-
maat_codegen
Bytecode code generation for the Maat programming language
-
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.
-
leo-std
Embedded Leo standard library source
-
c64-assembler
Commodore 64 assembler, outputs directly to .PRG or Dasm source code
-
nova-codegen-llvm
The Nova language's LLVM IR code generator (internal to the nova toolchain)
-
kombucha
A minimal and malleable programming language for symbiotic end-user programming
-
kio-lang
Kio — compiler and CLI
-
rust_mir2_wrapper
RUSTC_WORKSPACE_WRAPPER binary for rust_mir2 MIR extraction
-
nix-rs-eval
Nix language parser, compiler and bytecode evaluator for nix-rs, derived from snix-eval
-
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
-
tsr_semver
Semantic version ranges used by tsr module resolution
-
nyar-error
Error types for valkyrie language
-
treeedbgen-souffle-souffle
Generate Soufflé types and relations from the Soufflé tree-sitter grammar
-
listen-fire-checker
The listen-fire movement language checker: diagnostics, types and import links for a parsed movement
-
dolang-private-test
Test support utilities for Do language crates
-
monty-type-checking
A secure, snapshotable Python sandbox written in Rust
-
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.
-
hannibal-lexer
DFA based Lexer written in Rust
-
kz80_db
dBASE II clone for Z80 - Retro database on the RetroShield
-
monty-typeshed
A secure, snapshotable Python sandbox written in Rust
-
mux-lang
The Mux Programming Language Compiler
-
rucc-reactor
The rucc C compiler as a WebAssembly reactor, which runs the driver more than once in one instance
-
maat_types
Hindley-Milner type inference engine for the Maat programming language
-
whitespacers
A whitespace JIT-compiler, for when your whitespace just isn't executing fast enough
-
mailang-compiler
Compiler for MaìLang
-
rust-guile
Scheme runtime in your Rust program
-
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…
-
jzero-vm
Bytecode interpreter and VM for the Jzero language
-
zccache-compiler
Compiler detection and argument parsing for zccache
-
apollo-ariadne
A fancy diagnostics & reporting crate
-
tsr_arena
Owned arenas, identities and generation-scoped storage for tsr
-
tinymist-analysis
Typst Static Analyzers for Tinymist
-
santiago
A lexing and parsing toolkit for Rust
-
seacc
A sea-of-nodes C compiler, written in Rust
-
logics-rs
Logics is a user-friendly formula language with a subset of Python's expression syntax
-
wasi-assembler
Modern assembler for WASM and WASI (wit-component) - strongly typed, object-oriented, zero-dependency core
-
axioval-engine
Trusted capability compiler and deterministic source-neutral validation runtime
-
tidepool-codegen
Cranelift-based JIT compiler for Tidepool Core
-
jimtcl
Embed Jim Tcl in Rust
-
sabiruby-compiler
The reference mruby 4.1.0-rc2 compiler (mruby-compiler with its Prism parser, built as C) as a Rust library: Ruby source to RITE bytecode byte-identical to mrbc, and a Prism-based syntax-highlight map for editors
-
penne
pasta-oriented programming language that favors the goto-statement for flow control
-
spydecy-c
C AST parser for Spydecy transpiler with CPython API recognition
-
alloy-luau
Alloy: a strict superset of Luau that transpiles to plain Luau
-
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.
-
vexil-codegen-rust
Rust code generation backend for the Vexil schema compiler
-
syntax-core
Fast, multi-strategy parsing and transformation kit for Rust
-
wolfpack-parser
The parser of wolfpack. Internal part of wolfpack-lang, not a stable API
-
treeedb-python
Generate Datalog facts from Python source code
-
treeedb-cpp
Generate Datalog facts from C++ source code
-
treeedb-php
Generate Datalog facts from PHP source code
-
mogi_sleigh_parser
Parser for Sleigh specifications
-
maat_module
Module system and multi-file compilation for the Maat programming language
-
synoema-parser
Synoema — programming language optimized for LLM code generation
-
turing-lib
Turing library for Rust
-
nyar-assembler
Modern Nyar VM assembler - strongly typed, object-oriented, zero-dependency core
-
sap-shared
The shared crate for the SAP programming language
-
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… -
py-ast
Pin1Yin1 ast definition and parse for pycc-rs
-
swamp-code-gen-program
converts a Swamp program to swamp-vm opcodes
-
vexil-codegen-go
Go code generation backend for the Vexil schema compiler
-
tl-llvm
LLVM backend for ThinkingLanguage (Phase 30)
-
treeedb-go
Generate Datalog facts from Go source code
-
falsec
An interpreter and compiler for the esotheric programming language FALSE
-
graphcal-fmt
Type-safe, unit-aware, Git-friendly reactive programming language for engineering calculations
-
ling-mic
Microphone input and real-time audio capture for Ling
-
synoema-types
Synoema — programming language optimized for LLM code generation
-
leo-parser-lossless
Lossless syntax tree parser for the Leo programming language
-
jzero-parser
LR(1) parser for the Jzero language
-
lux-lang
The Lux programming language
-
calyx-opt
Compiler Infrastructure for Hardware Accelerator Generation
-
bock-pkg
Package management for Bock projects, including dependency resolution and lockfiles
-
moa_bitops
位操作原语与动态大小位图
-
vexil-codegen-ts
TypeScript code generation backend for the Vexil schema compiler
-
graphcal-io
Filesystem implementations for the Graphcal compiler
-
b2c2-compiler
b2c2におけるBASICコードをCASL2に変換する部分?
-
marigold-grammar
Grammar for the marigold language
-
py-declare
type declare system for pycc-rs
-
graphcal-package
Type-safe, unit-aware, Git-friendly reactive programming language for engineering calculations
-
rustc-demangle-capi
C API for the
rustc-demanglecrate -
parsuna
recoverable, pull-based parsers with precise errors
-
stailwc
An experimental transpiler to bring tailwind macros to SWC rocket
-
badder_lang
A specialized programming language built for programming puzzle game Robo Instructus
-
XLang-Rust
An experimental cross-platform dynamic strong-typed programming language written in Rust
-
graphcal-plugin-abi
Type-safe, unit-aware, Git-friendly reactive programming language for engineering calculations
-
maat_eval
Tree-walking interpreter and macro expansion engine for the Maat programming language
-
ezno
A fast and correct TypeScript type checker and compiler with additional experiments. For use as a library or through the CLI
-
panproto-llvm
LLVM IR protocol definition and lowering morphisms for panproto
-
stella_checker
Rust-based, speedy Lua type checker
-
nextjs_react_compiler_utils
Rust port of the React Compiler, vendored from facebook/react
-
ling-ast
Abstract Syntax Tree types for the Ling language
-
tvm
Rust frontend support for TVM
-
suffete
A standalone PHP type system: representation, comparison, and type checking primitives for static analysis tools
-
spade-hir-lowering
Helper crate for https://spade-lang.org/
-
forked_react_compiler_utils
Rust port of the React Compiler, vendored from react/react
-
moore-vhdl
The VHDL implementation of the moore compiler framework
-
sap-ast
The abstractact syntax tree crate for the SAP programming language
-
rucc-debug
DWARF 5 generation
-
tk-pg-rebase
Rebasing passes for Pauli graphs
-
assura-pipeline
Shared compiler pipeline for the Assura language
-
seraphine-core
Core of the seraphine programming language
-
onion-frontend
Compilation frontend for the Onion programming language - lexer, parser, and IR generator
-
qcs-sdk-python
Python bindings to qcs-sdk-rust
-
sphinx-lang
An intepreter for a dynamic language implemented in Rust
-
graphcal-plugin-host
Type-safe, unit-aware, Git-friendly reactive programming language for engineering calculations
-
xee-interpreter
Interpreter for XPath and XSLT
-
tang-compile
Graph optimization and compilation passes for tang
-
itsy
Strongly typed scripting language with a rusty syntax and nice Rust integration
-
magc
The Mag Language Compiler
-
eureka-optimizer
A short description
-
noxid-hmr-ir
The hmr-ir component of the Noxid compiler
-
pseudo_interpreter
A Pseudocode interpreter
-
bynk-ir
The declaration-level IR the Bynk emitter reads: service protocols, handler kinds, type shapes, store fields, and capability signatures, plus shared AST-walk helpers. Final crates.io release; superseded by bynk-model.
-
noxid-dom-ir
The dom-ir component of the Noxid compiler
-
flow_analyzer
Semantic analyzer for the Flow programming language
-
rajac-parser
Java parser for the rajac compiler
-
mutica-compiler
Compiler library for the Mutica programming language
-
ling-codegen
Code generation backends for Ling (bytecode, WASM, native)
-
telltale-vm
Bytecode VM for choreographic session type protocols
-
rosetta-stone-core
Core types and traits for the Rosetta transpiler
-
kache-client
Synchronous compiler client for the Kache daemon
-
bevy-brink
Bevy asset integration for brink ink stories
-
nuidl
The nucom IDL compiler
-
pl_0
pl/0 compiler implemented in rust
-
runmat-repl
Interactive RunMat REPL with line editing and Jupyter kernel integration
-
voile
dependently-typed row-polymorphic programming language
-
rlibc-extended
A minimal implementation of assumed symbols of libc
-
procss
CSS parsing and transformation framework
-
mosaic-lang
A compiler for Mosaic
-
saxaboom
Binding library for Metal Shader Converter
-
luau-syntax
Luau lexer, parser, AST, CST, and source utilities
-
pycrust
A sandboxed python interpreter (and soon to be compiler)
-
mimas-shared
Shared types and utilities for the mimas language. Internal to mimas; not intended for direct use.
-
edlc_codegen_cranelift
Cranelift codegen backend for the EDL compiler
-
ruby
Pure Rust implementation of Ruby runtime environment
-
bfy
Brainfu*k interpreter and REPL written in Rust
-
vyre-debug
Debugging CLI and inspection helpers for Vyre programs, lowering, and emitted shaders
-
tos-tbpf
Virtual machine and JIT compiler for eBPF programs
-
swamp-eval
tree-walking interpreter for executing the Swamp Abstract Semantic Graph (ASG) from
swamp-semantic. Primarily for debugging/testing, not performance. -
asa
Advanced Subleq Assembler. Assembles 'sublang' to subleq
-
claw-common
The Claw language common types and functions
-
phptaint
Security-focused PHP lexer, parser, AST, and configurable taint analysis engine
-
py-ir
Pin1Yin1 ir implementation
-
deed-explain
Generated pages for every diagnostic code deed can produce
-
snli
An interpreter for the Syntax Null Language Esolang
-
tr-lang
A programming language made to bring syntax closer to Turkish
-
voce-adapter-core
Voce IR deployment adapter trait and shared types
-
jzero-ast
Syntax tree data structures for the Jzero compiler
-
krnlc
Kernel compiler for krnl
-
diplomat_core
Shared utilities between Diplomat macros and code generation
-
blockly-rust-compiler
Rust compiler integration library for visual programming with Blockly - validate and check generated code
-
synoema-core
Synoema — programming language optimized for LLM code generation
-
hacspec
compiler
-
smc-assembler
assembler for a variety of MineCraft architectures
-
remir_llvm
The LLVM binding for the Remir library
-
graphcal-report
Type-safe, unit-aware, Git-friendly reactive programming language for engineering calculations
-
jzero-symtab
Symbol table types for the Jzero compiler
-
rosetta-stone-ir
Rosetta Intermediate Representation for cross-language transpilation
-
vulkane-slang-emit
The Slang compute-shader emitter for Unpopped: IR to Slang source, with HLSL overloaded intrinsics, StructuredBuffer operands and a [numthreads] entry. Moved from unpopped-slang; Vulkane owns Slang.
-
noxi-eval
Nix language parser, compiler and bytecode evaluator for noxi, derived from snix-eval
-
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.
-
fervid_css
Transformer for Vue
<style>blocks -
synoema-eval
Synoema — programming language optimized for LLM code generation
-
swamp-compile
Main driver for the Swamp compiler, orchestrating bootstrapping, dependency loading, parsing, and semantic analysis phases
-
spaik
Programming Language
-
haloumi-picus
Haloumi backend to the Picus Constraint Language
-
px-llvm-codegen-utils-version-macros
Version macros for LLVM codegen utilities
-
kernite-ptx
PTX for NVIDIA GPUs as kernite-lang writes it: each instruction checked against the types its name gives, printed for the driver
-
fishstringer-slang-emit
Slang compute-shader emitter for Unpopped: IR to Slang source, with HLSL overloaded intrinsics, StructuredBuffer operands and a [numthreads] entry. Moved from unpopped-slang and vulkane-slang-emit;…
-
tsr_parser
TypeScript and JavaScript parser for tsr
-
fastc
A safe C-like language that compiles to C11
-
haloumi-ir
Intermediate representation of the haloumi framework
-
tsr_project
Checker ownership and project slot lifetimes for tsr
-
prima-academy
Academic course classification primitives for Prima
-
lilac
Static site generator-esque tool for adding include statements to HTML
-
rustpython-compiler-core
RustPython specific bytecode
-
provekit_brillig_vm
The virtual machine that processes Brillig bytecode, used to introduce non-determinism to the ACVM
-
brink-intl
Internationalization tooling for brink stories
-
fidget-bytecode
Bytecode representation for Fidget expression tapes
-
cranefack
An optimizing brainfuck compiler
-
tsr_locale
Pinned TypeScript locale parsing and diagnostic language matching
-
graphcal-tenax
Type-safe, unit-aware, Git-friendly reactive programming language for engineering calculations
-
kernite-build
What kernite does with a module of kernels: the use cases, and the ports a machine implements
-
lovely
A delightful low-level systems programming language
-
oxie-compiler
Compiler for the Oxie programming language: Oxie to Rust source code
-
garnish_lang_runtime
Runtime and execution library for Garnish Lang
-
tan
language
-
langbox
framework to build compilers and interpreters
-
rat-in-a-tube
Rat In a Tube, Halo: Combat Evolved HSC Script Compiler
-
tsr_transformers
TypeScript declaration transformation for tsr
-
aegean
A fancy diagnostics & reporting crate
-
moa_rand
xoshiro256++ 伪随机数生成器
-
polypus-circuit
Pure-Rust quantum circuit representation with OpenQASM 2.0 export, used by Polypus. No PyO3 / Python dependency.
-
codemem-index
Tree-sitter code indexing for Codemem memory engine
-
diatom
programming language
-
type-sitter-gen
generate typed wrappers for tree-sitter grammars from node-types.json and queries
-
atlas_vm
The Atlas77 Virtual Machine
-
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)… -
spydecy-optimizer
Cross-layer optimizer for Spydecy transpiler with boundary elimination
-
tsr_json
Byte-preserving typed JSON encoding for tsr
-
jzero-lexer
Lexer for the Jzero language (a subset of Java)
-
llvm-ir-analysis
Static analysis on LLVM IR
-
claw-cli
The compiler for the Claw language
-
bfrunner
A Brainfuck interpreter in Rust, for shits and giggles. Not for production.
-
glslang-sys
Raw C bindings to glslang
-
compiler_base_parallel
A common domain programming language framework
-
graphcal-ratio
Reduced fixed-width rational numbers for Graphcal dimension exponents
-
typelisp-abi
Calling convention shared by typelisp's compiled code and its runtime. Internal crate of typelisp; not meant to be used directly.
-
ryna-language
An extensible programming language with a strong type system
-
airlang_ext
The Extension of Air Programming Language
-
portalis-cli
CLI for Portalis - GPU-accelerated Python to Rust/WASM transpiler
-
vyre-foundation
Foundation layer: IR, type system, memory model, wire format. Zero application semantics. Part of the vyre GPU compiler.
-
irvm-lower
The lowering library for IRVM to go to LLVM IR
-
graphcal-plugin
Type-safe, unit-aware, Git-friendly reactive programming language for engineering calculations
-
tsr_ast
TypeScript syntax trees, factories and binding storage for tsr
-
moa_unsafe_list
Linux 风格侵入式双向链表
-
draxl-lower-rust
Lower validated Draxl Rust-profile files to ordinary Rust
-
rajac-verification
OpenJDK compatibility verification runner for rajac
-
swamp-script-node
compiler node with documentation and meta information
-
synoema-lexer
Synoema — programming language optimized for LLM code generation
-
beadie-llvm
LLVM JIT backend adapter for beadie (via inkwell)
-
wesl-c
C bindings for the WESL compiler
-
rythonc
Command-line Python-to-Rust compiler for the Rython toolchain
-
moto
motivated automation
-
airl-interp
Tree-walking interpreter for AIRL IR with 74 builtins
-
relon-rs-shims
Runtime ABI shims for Relon AOT-compiled functions linked into Rust binaries
-
abrase-cli
CLI for the Abrase language
-
chimpanzee
Monkey programming language implementation (interpreter, compiler and formatter), with added features
-
cuda_builder
Builder for easily building rustc_codegen_nvvm crates
-
listen-fire-language
The listen-fire movement language service: completion, hover, definitions, diagnostics and fixes answered from the checker's own results
-
rosetta-stone-smalltalk
Smalltalk language frontend for Rosetta transpiler
-
assura-macros
Proc macros for inline Assura contract annotations in Rust
-
ling-core
Core types, errors, and compiler infrastructure for Ling
-
brk_rolldown_ecmascript
ECMAScript AST and parsing utilities for Rolldown
-
spyglys
programming language for text manipulation
-
portalis-transpiler
Python to Rust transpiler engine with WASM compilation support
-
pfcl-types
Core value types for PFCL: Value, Hash (SHA-256), runtime environment
-
py-codegen-c
C codegen backend implementation for Pin1Yin1
-
elworthy-expr
Symbolic expression AST, canonicalisation, and CSE for elworthy
-
python-packaging
Python packaging primitives implemented in Rust
-
wesley-emit-rust
Rust syntax-model emitter for Wesley IR
-
stickler-ffi
Safe, thread-serialized bindings to the Stickler embedding library
-
llvmkit-support
Shared support utilities for the llvmkit family (Span, Spanned, SourceMap)
-
pyoxidizer
Package self-contained Python applications
-
bcomp
A compiler for a subset of the BASIC language
-
torq_lang
A programming language for concurrent dataflow
-
elworthy-weight
Bismut-Elworthy-Li weight synthesis for elworthy
-
nvvm
High level bindings to libnvvm
-
zhc_pipeline
ZHC: Compilation pipeline
-
sorth
Forth inspired interpreted programming language
-
xlang_frontend
Frontend for XLang-Rust
-
ospl
the (UNFINISHED!!!) OSPL programming language
-
sui-bytecode
Bytecode compiler and VM for the sui Rust-native Nix evaluator
-
litua
Read a text document, receive its tree in Lua and manipulate it before representing it as string
-
spydecy
Self-hosted Python/C-to-Rust compiler-debugger with introspective debugging
-
decomp
Components of a decompilation pipeline
-
go-parser
The parser of the Goscript project
-
alder-runtime
Embedded V8 runtime for standalone Alder programs
-
nexus-lang-cli
Command-line interface and REPL for the Nexus network description language
-
typiskt
Type systems as a library
-
libbfi
Extendable brainfuck interpreter library
-
celsium
building interpreters
-
clover
A scripting language
-
edlc_docs
HTML renderer for documentation for the EDL compiler
-
steel-repl
REPL library for steel
-
dust-lang
General purpose programming language
-
claw-codegen
The Claw language Wasm code generator
-
intarsia
An extensible Rust optimization framework
-
cas-compiler
Bytecode compiler for CalcScript programs
-
sila-transpiler-infrastructure
transpiler infrastructure for every platform
-
y-lang
Compiler & Interpreter for the (rather new and very experimental) Y programming language
-
mir-rs
FFI bindings to MIR Project (https://github.com/vnmakarov/mir)
-
stck-interpreter
An interpreter for the stck language
-
polka-rustc
Compiles Polka bytecode to no-std Rust
-
tsr_format
TypeScript source formatting for tsr
-
lactea-eel
ns-eel2 / projectm-eval compatible expression language (MilkDrop per-frame/per-vertex code)
-
nope-lang
The nope programming language
-
phper-test
PHPer testing utilities
-
rlx-onnx-proto
Vendored pure-Rust ONNX protobuf types (protoc-free)
-
lactea-hlsl
MilkDrop HLSL (ps_2/ps_3 dialect + include.fx) to WGSL translator
-
devsper-compiler
Distributed AI Swarm Runtime
-
farmfe_utils
farm utils
-
tur
Turing Machine Language - Parser, interpreter, and execution engine
-
mica
user-friendly, embeddable scripting language
-
finx
A fast, lightweight embeddable scripting language
-
tsr_encoder
TypeScript syntax tree protocol encoding for tsr
-
slasherc
A programming language for school, built in Rust
-
fusabi
A potent, functional scripting layer for Rust infrastructure
-
crityp
Benchmark support for typst
-
mux-runtime
Runtime library for the Mux programming language
-
vyre-megakernel
Backend-neutral compiler for canonical Vyre megakernel artifacts
-
valua-transformer
AST mutation passes that lower Lua 5.5 features to Lua 5.1 equivalents
-
genotype_visitor
Genotype language visitor crate
-
deed-dap
A debug adapter for Deed
-
error_ctx
Minimal context error crate with Temporary/Permanent status and compiler-enforced context on public APIs
-
fnotation
lower-house syntax for programming language experimentation
-
b2c2-parser
b2c2におけるBASICコードのパーサー?
-
oakc
A portable programming language with a compact backend
-
nand7400
An assembler library for the nand7400 computer, created by me during my internship at the WCL
-
moore-common
The common core of the moore compiler framework
-
mini-brainfuck
A super small brainfuck interpreter and compiler
-
plexer
A Pattern-matching LEXER
-
spydecy-hir
High-level Intermediate Representation (HIR) for Spydecy transpiler
-
sleuth
Extremely opinionated testing framework generating an exact specification and reducing code to its minimal implementation
-
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… -
synoema-diagnostic
Synoema — programming language optimized for LLM code generation
-
treeedb-rust
Generate Datalog facts from Rust source code
-
syntax-parser-generator
Independent library for generating lexical-analyzers and LALR parsers
-
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… -
rlx-mlx-sys
Low-level MLX C++ build + C ABI shim for RLX (vendored mlx, NVRTC-free)
-
c2rust-refactor
C2Rust refactoring tool implementation
-
aikup
Manage multiple versions of aiken
-
polka-rs
Bytecode schema for the Myriad runtime (Abrase language)
-
patch-prolog-shared
Shared term representation and atom interning for patch-prolog2
-
xlang_vm_core
XLangVM for XLang-Rust
-
dynamik
A fast, powerful, expressive and typesafe language
-
pushr
based interpreter for Push programs
-
cambridge-asm-cli
Run pseudoassembly from Cambridge International syllabus 9618
-
ag-c
The ag language compiler - a Rust-inspired functional language
-
assura-llm
LLM provider abstraction and contract analysis for Assura
-
haloumi-backend
Generic backend API of the haloumi framework
-
walter-redditlang
Build tool for https://github.com/elijah629/redditlang
-
decy-debugger
Interactive debugger for Decy C-to-Rust transpiler with spydecy integration
-
pfcl-resolver
Name resolver for PFCL: resolves catalog names to SHA-256 hashes at load time
-
conventional_commits
A lightweight parser following the conventional commit standards
-
worldinterface-flowspec
FlowSpec parser, validator, and compiler to ActionQueue DAG
-
cure-python-parser
Fault-tolerant Python parser (indentation, implicit joins, 3.15 syntax) for cure
-
beadie-cranelift
Cranelift JIT backend adapter for beadie
-
galvan-ast
AST for the Galvan programming language
-
tsr_jsnum
JavaScript numeric parsing and formatting for tsr
-
ling-lex
Lexical analysis and polyglot tokenization for Ling
-
ptx_compiler
High level bindings to CUDA's ptx compilation APIs
-
rusty-basic
Tiny BASIC interpreter written in Rust
-
unpopped-cpu-c
portable-C99 reference emitter for Unpopped: lowers a neutral
KernelPlanto C source that compiles on any C compiler, with no vendor intrinsic, no conditional compilation, and no device… -
bpf-ins
working with eBPF instructions
-
ape_lexer
lexical analysis for Aperture programming language
-
plato-dynamic-locks
Runtime lock accumulation — learns constraints from compilation/experience runs, extending static gates with dynamic knowledge
-
rurust
High level Ruby VM bindings
-
tsz-cli
CLI binaries for the tsz TypeScript compiler
-
cedar-policy-core
Core implementation of the Cedar policy language
-
relon-object-link
ET_REL -> ET_DYN link pass used by the v5-gamma native AOT pipeline before handing bytes to relon-object-cache
-
roost-lang
Interpreter library for the roost language
-
lithia
Embeddable and simple lisp dialect
-
paramodel-plan
Paramodel test-plan layer: TestPlan, Axis, ExecutionPolicies, OptimizationStrategy, TrialOrdering, plan-level bindings
-
myriad-rs
VM runtime for Polka bytecode, computation core
-
macroassembler
writing portable x86-64/riscv64/aarch64 assembly code in Rust
-
elworthy-diff
Symbolic differentiation for elworthy expression trees
-
brainease_transpiler
A brainf*ck-style programming language, but readable
-
ktrs-psi
Typed Kotlin PSI accessors over the ktrs syntax tree, mirroring the compiler's psi-impl
-
argmin_testfunctions
Test functions for optimization algorithms
-
sk-lang
The SK Programming Language interpreter
-
assura-lsp
LSP server for the Assura contract language
-
ezc
A compiler for ez
-
tsr_fswatch
Native filesystem watcher backends (FSEvents, inotify, fanotify, kqueue) for tsr
-
send-future
Ergonomic and performant fix for https://github.com/rust-lang/rust/issues/96865
-
assura-mcp
MCP (Model Context Protocol) server for Assura AI agent integration
-
mojo-rs-mojom
Mojom language toolchain: lexer, parser, AST, imports, module resolution, semantic validation. Accepts upstream .mojom corpora.
-
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.
-
go-types
The type checker of the Goscript project
-
rustc-hash
A speedy, non-cryptographic hashing algorithm used by rustc
-
tsr_tspath
TypeScript-compatible path operations for tsr
-
rubyrs-cext
CRuby-shape C ABI for hosting C extensions inside rubyrs (spike: Level 0)
-
findpython
Find python executables on your system
-
sollua
An elegantly fast lua 5.4 parser
-
synoema-repl
Synoema — programming language optimized for LLM code generation
-
simple-symbol
Convenient, basic String interning
-
mijit
Experimental JIT compiler generator
-
marzipan
A macro processor for ZZT worlds
-
brainfuck-plusplus
A brainfuck interpreter and compiler with some extra functionality
-
strop
stochastically generates machine code
-
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.
-
Cecile
Cecile Programming Language that is designed to be simple, fast
-
duskphantom-backend
Backend for DuskPhantom Compiler
-
scoutlang
A web crawling programming language
-
hern
A small language compiled to Lua for LuaJIT
-
rl-cranelift
Cranelift-based JIT compiler backend for the rl-lang programming language
-
dark-vm
A new VM called the DarkVM, which focuses on speed and simplicity
-
mrdo
A programming language (compiler, assembler, VM, and REPL) for working with collections of data
-
pfcl-parser
Parser for PFCL — pure functional language with content-addressed catalog
-
b2c2-casl2
b2c2におけるCASL2の雑なパーサー?
-
jit
Just-In-Time Compilation in Rust using LibJIT bindings
-
yamlate
A cross-language interpreter library that dynamically evaluates YAML attributes given variable bindings
-
lumi-core
Core lumi library
-
ling-polyglot
Polyglot lexicon system - 16+ human languages
-
genotype_compiler
Genotype language compiler
-
lunita-util
lunitalibrary -
llts_codegen
LLTS codegen — LLVM IR generation via Inkwell
-
bynk-strip
Strip-only TypeScript-to-JavaScript for the Bynk compiler: erases type syntax with oxc, preserving runtime semantics and value imports
-
prql-compiler
PRQL is a modern language for transforming data — a simple, powerful, pipelined SQL replacement
-
guardc
GUARD → FLUX verified compiler
-
lambdust
A Scheme dialect with gradual typing and effect systems
-
smpl
Core library to compile the SMPL language
-
extendable_vm
that simplifies implementation of stack VMs
-
tsr_api
Snapshot-scoped compiler API handles, printing and formatting for tsr
-
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… -
erg_type
APIs for Erg types
-
yoloxide
Yolol language from the upcoming game Starbase
-
tsr_glob
The pinned TypeScript language-server glob grammar: parse, render and match
-
lancelot-bin
binary analysis tools for x32/x64 PE files
-
slothlang
A weird, slow and a bit moldy interpreted programming language
-
minicode
Esoteric programming language
-
flow_ast
Abstract Syntax Tree definitions for the Flow programming language
-
kdl-script
execute kdl documents!
-
tsr_nodebuilder
Type-to-syntax builder contracts and flags for tsr
-
hcb2lua_decompiler
A decompiler for HCB scripts to Lua
-
brainease_lexer
A brainf*ck-style programming language, but readable
-
ketos
Lisp dialect scripting and extension language
-
silt-lua
A pure rust Lua interpreter and virtual machine
-
alan-von-palladium
The Alan von Palladium Programming Language - A systems programming language combining Turing's correctness with von Neumann's performance
-
safe_wren
A safe, pure-rust implementation of wren.io, drop-in replacement for wren.io's C implementation
-
qspquest-modeling
Model compiler, simulation and fitting engine for QSPQuest
-
vosh
General-purpose programming language
-
rlci
Overly-documented Rust-powered Lambda Calculus Interpreter
-
ts-runtime-typechecker
A command line tool that generates ts/js typechecker functions from typescript types
-
calyx-ir
Compiler Infrastructure for Hardware Accelerator Generation
-
py-rustitude
create and operate models for particle physics amplitude analyses
-
retrolang-asm
Z80 assembler for RetroLang (based on FantASM by Guy Black)
-
destack-rs
Rust compatibility crate for Destack
-
calyx-frontend
Compiler Infrastructure for Hardware Accelerator Generation
-
moss
Experimental Moss interpreter
-
flow_compiler
JIT and AOT compiler for the Flow programming language using Cranelift
-
callisp
A lisp interpreter that can be used with WASM
-
logic-ir
Universal Tri-Axial Fractal Topology (ZYModel) implementation in Rust
-
lolli-cli
Command-line interface for the Lolli linear logic workbench
-
ilex
quick and easy lexers for C-like languages
-
enki-parsu
Hardware profiling and JIT compilation synthesis engine for Enki
-
the-code-graph-parser
Multi-language source code parser for The Code Graph
-
barfs
Befunge JIT
-
zymodel
Universal Tri-Axial Fractal Topology (ZYModel) implementation in Rust
-
bff
A complete Befunge 98 interpreter in Rust
-
coe-rs
Type coercion
-
fexplib
lower-house syntax for programming language experimentation
-
zul
General-purpose programming language
-
logicuniverse
Universal Tri-Axial Fractal Topology (ZYModel) implementation in Rust
-
rust-bf
A Brainfuck interpreter, generator, REPL, and IDE written in Rust
-
sddrs
Bottom-up Sentential Decision Diagram compiler library
-
ashpaper
Rust Inpterpreter for Esopo language AshPaper conceived by William Hicks
-
mblf
The MBLF-To-BF compiler written in Rust with Pest. MBLF is a programming language on top of the esoteric programming language Brainfuck
-
brainfuck-cli
Brainfuck CLI interpreter written in Rust
-
lexviz
A customizable lexical analyser tool which also allows you to visualize the NFAs and DFAs generated
-
boron-lang
efficient, compiled programming language
-
aiscript-arena
safe, incrementally garbage collected arenas
-
lead_lang_interpreter
Interpreter of the Lead Programming Language
-
funcscript
universal core runtime (Rust VM) with C ABI and CLI
-
tsar
Tsar programming language
-
comet-rs
Rust eDSL for COMET: domain specific COMpiler for Extreme Targets
-
remolt
Embeddable TCL-ish interpreter for Rust applications
-
elworthy-codegen
Cranelift lowering of elworthy expression trees
-
paijorot
interpreted programming language implemented in Rust. It's designed as a hobby project with unique 'brainrot' syntax. ***(FULLY AI WRITTEN)***
-
pr47
A semi-experimental programming language. Still working in progress.
-
tattle
Error reporting for compilers
-
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.
-
haloumi-inject
Injection utilities for hot-patching crates
-
aspl
Programming Language
-
symboscript-formatter
SymboScript formatter
-
calyx
Compiler Infrastructure for Hardware Accelerator Generation
-
adana-script-core
namespaces aliases for command lines & basic scripting language
-
mitex-cli
CLI for MiTeX
-
rtk-rustc-driver
The rustc driver (don't use this directly) for Rust Type Kit - query Rust types and produce FFI types
-
pfcl-catalog
Content-addressed function catalog for PFCL — identity is SHA-256 of typed source
-
hugr-core
Quantinuum's Hierarchical Unified Graph Representation
-
treeedbgen-souffle-java
Generate Soufflé types and relations from the Java tree-sitter grammar
-
stak-primitive
Stak Scheme primitives
-
haskelujah-backend-cranelift
Cranelift native code backend for the Haskelujah Haskell compiler
-
tsr_jsonrpc
JSON-RPC 2.0 messages and Content-Length framing for tsr
-
cilk
(Toy) Compiler Infrastructure inspired by LLVM
-
fr
A programming language with an unusual compiler backend
-
garden-lang-parser
A live programming language
-
dash-lang
interpreted language
-
hyeong
Hyeo-ung Programming Language Compiler
-
hornbeam
template engine (high-level crate for use in applications)
-
scout-parser
A web crawling programming language
-
ara_parser
A fault-tolerant, recursive-descent parser for Ara Programming Language 🌲
-
cxc
A high performance scripting language
-
ape_ast
abstract syntax tree for Aperture programming language
-
llts_driver
LLTS driver — pipeline orchestration from TypeScript to native
-
tin
statically structurally typed embeddable programming language
-
bwd
Backwards linked-lists
-
whipplescript-core
Shared core types for WhippleScript workflows
-
rtlola-streamir
A framework for the compilation of stream-based languages through an intermediate representation
-
py-codegen
pycc-rs codegen interface
-
flow_stdlib
Standard library for the Flow programming language
-
py-codegen-llvm
llvm codegen backend implementation for Pin1Yin1
-
lia
A high-level language for Rust
-
umbra-lang
macro-based scripting language
-
inline-vbs
Embed VBScript (and JScript, Ruby, Perl, ...) code inside Rust
-
rajac-classpath
Classpath loading and symbol extraction for rajac
-
rustc_codegen_nvvm
A codegen backend for Rustc which targets the libnvvm CUDA library
-
dynasm-lib
A pure rust assembler, not a JIT. Used within direct-asm for maximum control over assembly.
-
language-reporting
Diagnostic reporting for programming languages
-
ksplang
interpreter
-
luallaby
Work in progress A pure-Rust Lua interpreter/compiler
-
genotype_lang_rs_core
Genotype language Rust target core crate
-
rusm-jsc
Build-time QuickJS bytecode compiler for RUSM TS bundles (version-locked to the js-runner's rquickjs)
-
glulx-asm
Assembler for the Glulx Virtual Machine for Interactive Fiction
-
runmat-core
Host-agnostic RunMat execution engine (parser, interpreter, and JIT integration)
-
easyjsc
easyjs to JS/wasm compiler
-
haskelujah-core
Core language, desugaring, and simplification for the Haskelujah compiler
-
yggdrasil-shared
Yggdrasil Compiler core shared components
-
hydroper_jet_compiler
Hydroper Jet Language Compiler
-
flow_parser
Parser for the Flow programming language
-
clutils
A common library for building interpreter and compiler
-
ullage
Programming Language
-
dashc
Compiler, lowering, and artifact generation for DashScene
-
swift-precompiler
A precompiler for Swift that allows you to use additional macros, include files, and more
-
cyclang-parser
Cyclang is a toy language built in LLVM
-
clac-lang
Reference implementation of Clac++, a simple stack-based postfix (reverse polish notation) calculator/programming language
-
rasm-lang
RASM is a small Interpreted Programming Language
-
ellie_bytecode
Bytecode assembler/encoder/decoder for ellie language
-
skiff
An immutability-first, functional scripting language with a friendly syntax and compiler/interpreter written in Rust!
-
definitely
Codepaths that are statically unreachable according to the compiler's intraprocedural control flow analysis
-
impral
A command parsing and evaluation library for a LISP dialect, specialized for commandline input
-
spydecy-python
Python AST parser and transpiler frontend for Spydecy
-
spydecy-codegen
Rust code generator for Spydecy transpiler - generates idiomatic safe Rust
-
husk-parser
Parser for the Husk programming language
-
nadesiko3
Japanese programming language Nadesiko v3
-
fusabi-pm
Fusabi Package Manager
-
controlmap-parser
(De)Serializer of
controlmap.txtin Skyrim -
autophagy
AOT compiler for Rust
-
rohanasantml
An easy way to write your messy html code in a better way
-
scout-lexer
A web crawling programming language
-
lolli-prove
Proof search for the Lolli linear logic workbench
-
cow-parser
A parser for the esoteric Cow programming language
-
expr-solver
Solves a mathematical expression while following precedence and associativity
-
decy-core
Core transpilation pipeline for C-to-Rust conversion
-
kronk
interpreter - a silly, experimental language with surprisingly loud output
-
scrapile
A somewhat fully-fleged rust-like programming language that, surprisingly, compiles to scratch
-
blazefuck
A blazingly-fast (interactive) Brainfuck interpreter
-
sabre-lang
The sabre programming language
-
flow_runtime
Runtime library for the Flow programming language
-
virdant
modern hardware description language
-
harborc
A language that ports: targeting your thermostat, UFO, and kitchen sink
-
csw-generate
Code generation for the Categorical Semantics Workbench - generate type checkers and interpreters from derived type systems
-
betadin
programing language for research purposes
-
flow_transpiler_java
Java bytecode transpiler for the Flow programming language
-
shortlang
A programming language designed for code golfing
-
typst
A new markup-based typesetting system that is powerful and easy to learn
-
mochi-lang
concatenative programming language
-
jonlang
basic scripting language made to learn rust
-
symboscript-lexer
SymboScript lexer
-
symboscript-parser
SymboScript parser
-
rocks-lang
Crafting Interpreters' Lox Language
-
fervid_transform
Transformations for the fervid crate
-
vexity
Tiny scripting language for hacking on abstractions of financial markets
-
b2c2-stat
デバッグ用にところどころで使ってるぽい
-
calyx-stdlib
Compiler Infrastructure for Hardware Accelerator Generation
-
lolli-codegen
Code generation for the Lolli linear logic workbench
-
agent-wire-compiler
Canonical Wire action compiler primitives for the agent-wire.com substrate
-
rispy
A Lisp in Rust
-
winch-codegen
Winch code generation library
-
dragon_blade
A transpiler from Rust to Overwatch Workshop
-
hebi
A dynamic scripting language
-
molt
Embeddable TCL interpreter for Rust applications
-
husk-dts-parser
TypeScript declaration file (.d.ts) parser for Husk
-
rustpython-bytecode
RustPython specific bytecode
-
beadie-core
Bead chain, broker, hotness policy, swap, and deopt — no JIT backend
-
jaust
Java ecosystem tools in rust a learning project
-
ironplc-plc2x
Compiler front-end for ironplc
-
leuchtkraft
A logical programming language
-
sassers
A Sass compiler in Rust
-
mri-sys
Rust bindings to Mat'z Ruby interpreter
-
math-jit
Compile arithmetic expressions to native code
-
husk-lang
The Husk programming language compiler
-
terl
a general parser
-
bund_stdlib_text_classifier
Text classification using Bayes classifier for BUND programming language
-
sylt-std
Standard library for the Sylt programming language
-
bytebeat-cli
An LLVM-powered program to JIT-compile bytebeats and play them through your speaker
-
rshyeong
Hyeong-lang interpreter
-
logi_code
A scripting language do executing combinational circuits
-
binpattern
binary code pattern extractor for yaras
-
seraphine-cli
CLI for the Seraphine programming language
-
scout-json
JSON representation of ScoutLang AST
-
garguile
guile bindings for rust
-
bpf-script
A small scripting language and compiler for creating eBPF programs at runtime
-
autolang
Auto is a programming language for automations in various scenarios
-
NULL
Interpreter for the NULL language
-
lunar-lang
Lunar is a compiler that generate mruby bytecodes from Lua script
-
rail-lang
A straightforward programming language. Rail is currently experimental and subject to drastic breaking changes.
-
ttk91
A parser, compiler and emulator library for the TTK91 instruction architecture
-
renyi_vm
The Renyi virtual machine: bytecode, values, the library primitives and the runner (milestone M3)
-
fxrazen
compiler
-
lolcode
C compiler
-
claw-resolver
The Claw language name and type resolver
-
exers
compiling and running other code in sandboxed environment
-
tsr_incremental
The incremental program and its build info (tsBuildInfo) for tsr
-
brainfuck-exe
A brainfuck interpreter implemented in rust
-
brainoxide
An optimizing Brainfuck compiler/interpreter
-
flow_transpiler
Transpiler infrastructure for the Flow programming language
-
rpg-compiler
A compiler library for the rpg esoteric programming language
-
brainstem
A Brainfuck compiler and interpreter library, with a BrainStem frontend language
-
setjmp
/ longjmp support
-
ruski
combinator calculus
-
hephasm
Assembler for Asmodeus architecture with macro support and extended instructions
-
dez80
A Z80 instruction decoding and (dis)assembly library
-
yggdrasil-parser
Yggdrasil parser by yggdrasil
-
lolli-parse
Parser for the Lolli linear logic workbench
-
vtl-rs
Very Tiny Language (VTL) in Rust, inspired by the historical VTL-2 on Altair 680b and others
-
libxas
Extendable Assembler library
-
pitusya
Programming Language
-
cbe_rbpf
Virtual machine and JIT compiler for eBPF programs
-
mindfuck
Brainfuck interpreter in Rust
-
s-expression
parser
-
csw-derive
Type system derivation engine for the Categorical Semantics Workbench - derive type theories from categorical structures
-
baracuda-nvrtc-sys
Raw FFI bindings and dynamic loader for NVIDIA NVRTC (runtime CUDA-C++ to PTX compiler)
-
fervid_parser
Vue SFC parser for the fervid crate
-
symboscript-types
A symbolic programming language SymboScript types
-
ruby-sys
Low level bindings to MRI, Matz's Ruby Interpreter
-
scriptplan-bash
Experimental Bash language parser and runtime for
-
reporting
diagnostic reporting for compilers
-
orchidlang
An embeddable pure functional scripting language
-
alicorn
Rust embedding of the Alicorn compiler
-
theforce
A Star Wars inspired programming language
-
oris
An interpreter for Monkey
-
calcit_runner
Interpreter and js codegen for Calcit
-
py-lex
lex definition for pycc-rs
-
hematita
A memory safe Lua interpreter
-
claw-ast
The Claw language Abstract Syntax Tree (AST)
-
darklua-demo
Transform Lua scripts
-
dismael
Disassembler for Asmodeus binary files with intelligent analysis
-
tur-cli
Command-line interface for Turing machine simulator
-
llmcc-python
llmcc: llm context compiler
-
zub
A fast, stack-based virtual machine for dynamic languages, with an intuitive IR-builder, garbage collection and NaN-tagging
-
seher
official crate
-
vyre-lints
Lego-block enforcement lints for vyre. Forbids raw IR construction in dialect crates.
-
llts_frontend
LLTS frontend — oxc parser and semantic analysis wrappers
-
binks
scripting language
-
cxx-llvm
cxx-style FFI bindings to the LLVM C++ API
-
brainfuckr
brainfuck interpreter written in Rust
-
csw-core
Core categorical structures for the Categorical Semantics Workbench - define categories and derive type systems
-
xlang_abi
ABI safe interfaces used by xlang
-
xlang_host
Interface for determining and using platform-specific properties of the host system
-
pddl_rs
PDDL parser
-
yagbas_asmtypes
The assembly data type for the yagbas compiler
-
bsharp_lsp
The B# programming language!
-
oxie-from-rust
Translates Rust source code into idiomatic Oxie
-
llvm_stackmap
capable of parsing stack maps emitted by the LLVM compiler
-
cargo-whynot
Cargo subcommand to discover why a function is unsafe
-
moore-circt
Rust wrappers around the CIRCT API
-
compiletest_rs
The compiletest utility from the Rust compiler as a standalone testing harness
-
ape_parser
syntax analysis for Aperture programming language
-
numlang
A compiler for an esolang that uses hexadecimal
-
hyperparse
A HyperText Markup Language (HTML) parser written in Rust. (WIP)
-
relo
A custom programming language with a readable syntax (RELO)
-
cartes_rbpf
Virtual machine and JIT compiler for eBPF programs
-
rigz_runtime
Handles parsing and converting rigz to its VM instructions (for syntax highlighting use tree-sitter-rigz instead)
-
bfjit
Brainfuck JIT VM tutorial
-
brainfork
A compiler for Brainfuck written in Rust
-
lua_engine
lua engine
-
qxq
A playground for interpreters and JIT compilers
-
mutica-core
Core library for the Mutica programming language
-
hydroper_razen
Razen MXML compiler
-
luna-lib
a light weight interpreted programming language
-
langen
create programming languages
-
unidades
playing with physical units
-
dunh
Highlights code for printing
-
mlua-image
Lua bindings and embedding of the Rust based 'image' imaging library
-
nexus-lib
The raw implementation of the nexus scripting language
-
lolli-extract
Term extraction for the Lolli linear logic workbench
-
monkey-rs
Monkey programming language interpretter
-
llvm-alt
A wrapper for LLVM, a powerful library and toolkit for compilers
-
diatom-std-core
Diatom core standard library
-
kind-pass
A lot of compiler passes for the kind compiler
-
lovm2
a lightweight virtual machine with a focus on simplicity and extendability
-
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
-
dlang
Programing language from scratch
-
sap-lexer
The lexer crate for the SAP programming language
-
lazyk-rust
Interpreter for Lazy K programming language
-
haloumi-llzk
Haloumi backend to LLZK
-
genotype_json_schema
Genotype language JSON Schema crate
-
palate_polyglot_tokenizer
A generic programming language tokenizer
-
compiler-builtins-snapshot
Snapshot of the compiler-builtins crate
-
lincoln
A low level programming language features linear types and direct manipulation of continuation (returning points)
-
rajac-compiler
Compiler pipeline orchestration for rajac
-
fervid_napi
Vue SFC compiler written in Rust
-
calyx-backend
Compiler Infrastructure for Hardware Accelerator Generation
-
walnut
Walnut File Systwm Experimental file system with inode level encryption
-
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…
-
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
-
bock-core
Core stdlib registry and runtime primitives for the Bock language
-
leo-span
Span handling for the Leo programming language
-
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… -
yes-lang
Scripting Language
-
calyx-utils
Compiler Infrastructure for Hardware Accelerator Generation
-
moore-svlog
The SystemVerilog implementation of the moore compiler framework
-
kind-derive
Derive generator the kind compiler
-
ssa-cc
Traits for compiling SSA IR to C
-
target-lexicon
LLVM target triple types
-
cranelift-simplejit
JIT library backed by Cranelift
-
seer
symbolic execution engine for rust
-
vue-oxc-parser
Covert Vue AST (vue-compiler-core) to JSX AST (oxc)
-
swc_js_sourcemap
Basic sourcemap handling for Rust
-
sap-interpreter
The interpreter crate for the SAP programming language
-
vicis
Manipulate LLVM-IR in Pure Rust
-
depyler-graph
Dependency graph analysis for Python-to-Rust transpilation error reasoning
-
oak-glob
Glob pattern language support for Oaks
-
sylt-parser
Parser for the Sylt programming language
-
c-emit
Polished builder API to write C Code
-
spl_frontend
Compiler-Frontend for SPL
-
langpipe
A flexible Rust library for building custom compilers and interpreters with a modular pipeline for lexing, parsing, transforming, optimizing, and generating code
-
libdusk
implements most of the compiler for the Dusk programming language, in library form
-
cyclang-backend
Cyclang is a toy language built in LLVM
-
ojisan_fuck
Brain-fuck interpreter parsing emoji used by Japanese ojisans
-
scout-interpreter
A web crawling programming language
-
laspa
Lisp-like language built with Rust
-
oters_lang
Language definitions and interpreter for the oters programming language
-
codegem
A small code generation library
-
gnu-libjit
A safe rust wrapper around the libjit just in time compiler
-
emei
JIT/AOT backend codegen framework
-
stak-minifier-macro
Macros to minify Stak Scheme source codes
-
kernite-macros
Kernels written in place:
#[kernels]on a module compiles each function in it that names an ABI -
ldpl
LDPL 4.4 compiler in Rust
-
symboscript-optimizer
SymboScript optimizer
-
ilvm
An interpreter for an assembly-like language
-
rush-interpreter-vm
A rush interpreter leveraging a micro-compiler alongside a VM for its runtime
-
typeslice
type-level slices
-
kind-target-kdl
KDL target for the kind compiler
-
metaltile-core
Core IR types and data structures for the MetalTile GPU kernel DSL
-
husk-types
Type definitions for the Husk programming language
-
vexc
Compiler and toolchain for the Vex programming language
-
string_cache_plugin
A string interning library for Rust, developed as part of the Servo project − compiler plugin
-
elina
Safe, high-level Rust wrapper for ELINA
-
parser-c
Macros for parser-c
-
flow_lexer
Lexical analyzer for the Flow programming language
-
llvm-pm-sys
Raw FFI bindings for LLVM new PassManager C++ stubs
-
brainfuck
interpreter and modules
-
qvnt-qasm
A OPENQASM 2.0 Parser
-
wysk
A statically typed functional language with type inference, ad-hoc polymorphism, and an extensible operator syntax. Influenced by Rust, ML, and Haskell.
-
tinymist-core
Tinymist core library
-
genotype_writer
Genotype language writer crate
-
sym-lang
Sym Lang is a lightweight stack-based programming language that uses symbols and numbers
-
gex_sys_build_parse_mak
Parse mak file to build gex-sys
-
blink_runtime
Runtime lib for creating plugins for blink
-
swc_ecma_transforms_base
rust port of babel and closure compiler
-
koi-gc
koi programming language garbage collector
-
cluna
convert Lua code into Clue code Made by MarkosTh09
-
jkl-lang
Open Source Programming Language
-
smpli
Interpreter for the SMPL language
-
bfmod
Brainfuck lexer and compiler library for Rust
-
wrought
compiler
-
sylt-compiler
Compiler for the Sylt programming language
-
silkworm_err
Compiler diagnostics for silkworm
-
synoema-codegen
Synoema — programming language optimized for LLM code generation
-
datex-core
The DATEX Core Rust implementation
-
fennec-vfs
Fennec Programming Language
-
tin-lang
tin: a statically structurally typed embeddable programming language
-
ara_source
A Source library for Ara Programming Language 🗃
-
inc
Incremental approach to compiler construction
-
baracuda-cuda-parse
CUDA -> IR frontend for the neutral
unpoppedkernel generator: the tree-sitter grammar binding (parse_cuda), the CUDA residue list, and theCUDAFrontenddescriptor. Depends… -
lmntalc-core
Backend-neutral compiler core for lmntalc
-
sieve-rs
Sieve filter interpreter for Rust
-
ext-string
An attempt to extend rust String struct with functionality from other programming languages
-
bitsyc
Bitsy compiler written in Rust
-
jack_compiler
Jack compiler for the nand2tetris course
-
a4
A forth-inspired, bytecode-compiled scripting language for Anachro Powerbus
-
moore-svlog-hir
The HIR of the SystemVerilog implementation of the moore compiler framework
-
rtlola2rust
A compiler from RTLola to Rust through StreamIR
-
songe
Interpreter for a Scheme-like language for graphics and games
-
mdl_monkey
Monkey programming language from https://interpreterbook.com/
-
lld_rs
Bindings for LLD
-
woojin
Woojinlang interpreter written as Rust
-
lemonlang
an experimental, modern, purely safe, programming language
-
skeletree-core
Domain types shared across Skeletree: symbols, edges, ids. Zero I/O.
-
dependency_lister
Tools to list dependencies from .d files generated by clang or GCC
-
kind-checker
Type checker for the kind compiler
-
uwcl_rbpf
Virtual machine and JIT compiler for eBPF programs
-
llk
A fast, little an easy to understand LL(k) (LL(1) for now) library and compiler compiler (soon)
-
lexariel
Lexical analyzer for Asmodeus language
-
carlo
interpreted programming language
-
falsec-compiler
FALSE compiler
-
vue-compiler-core
Vue compiler in Rust's core component
-
lolli-viz
Visualization for the Lolli linear logic workbench
-
fennec
Programming Language
-
cas-vm
Virtual machine that executes CalcScript bytecode
-
swamp-node
compiler node with documentation and meta information
-
oxc_module_lexer
A collection of JavaScript tools written in Rust
-
genotype_lang_rs_visitor
Genotype language Rust target visitor crate
-
rs-luau
Minimal overhead Luau bindings for Rust!
-
mindblown
Brainfuck to x86 ELF compiler with batteries included
-
bfup
Preprocessor for brainfuck-like languages
-
synox
Program synthesis of string transformations from input-output examples
-
rpiet
An interpreter for Piet, the esoteric programming language
-
libicsneo
Rust API for libicsneo
-
malbolge
Programming Language in Rust
-
jsompiler_common
Common utilities for jsompiler
-
kind-span
Describes locations for the Kind compiler
-
cang
A coin based interpeter
-
citadel-frontend
The frontend of the citadel compiler backend
-
bftextmaker
generate brainfuck code that prints out a given string
-
shulkerbox
creating Minecraft datapacks in Rust
-
linguist-rs
that can be used to detect programming languages
-
ingot-syntax
Abstract syntax tree for the Ingot agent language
-
portal-pc-waffle-frontend
Frontend (Wasm to IR) for the WAFFLE Wasm analysis framework
-
sourcemap-resolver
Sourcemap resolving library and CLI
-
prism-compiler
An adaptive and functional programming language
-
luajit
calling LuaJIT from Rust
-
rush-parser
A lexer and parser for the rush programming language
-
codelighter
A fast error, warning and notes highlighter for Rust
-
compile-in-memory
dynamically compile and load C/C++ code at runtime, using the platform's host compiler
-
typed-sf
Typed ready-to-use implementation of SmallF*ck language in Rust
-
stak-macro
Macros to integrate Stak Scheme
-
autophagy-llvm
LLVM backend for Autophagy
-
bsharp_ir
The B# programming language!
-
liblox
VM of the lox language
-
rigz_ast
AST parser for the rigz programming language
-
rustc-hex-viewer
compiler as a hex viewer
-
ferrum_compiler
Compiler library for the Ferrum programming language
-
typed-eval
A type-safe expression evaluation engine
-
stack-assembly
minimalist, stack-based, assembly-like programming language
-
tlisp
Lisp interpreter in Rust
-
tinylj
calling LuaJIT from Rust
-
brainterpreter
An interpreter for a Bauble toy programming language
-
genotype_lang_py_codegen
Genotype language Python target codegen crate
-
rush-analyzer
A semantic analyzer and type-annotator for the rush programming language
-
intarsia-build
Build helpers for compiling ISLE rulset files in build scripts for Intarsia optimizers
-
fennec-common
Fennec Programming Language
-
quench
A programming language
-
OOLANG
An esoteric stack-based programming language, where all instructions are different variations of the character 'O'
-
llvm-sys-featured
Bindings to LLVM's C API
-
haloumi-core
Core types and traits of the Halo2 frontend for LLZK
-
fortraith
Compile-time compiler that compiles Forth to compile-time trait expressions
-
rumya-binding
Rumya programming language's binding for Rust
-
liexpr
parsing and evaluating simple expressions
-
ryft-core
Core abstractions of the Ryft library
-
ugo
uGo Compiler
-
leftpad-str
Obviously the best crate for the Rust programming language. The crate serves the only goal of implementing
leftpadfunction. -
rust-scheme
Scheme(R7RS) interpretor/compiler rust implementation
-
rivescript-core
Core data types and traits for RiveScript
-
parsentry-core
Core types and traits for Parsentry
-
rustpython-vm
RustPython virtual machine
-
slj
Programski jezik v slovenščini | A programming language in Slovenian
-
bund_stdlib_analysis
Numeric and text analysis for BUND programming language
-
gs2compiler
Compiles GS2 source code into GS2 bytecode
-
op8d_lexemizer
Opinionated library for transforming code to a vector of Lexemes
-
flycatcherc
The front-end of the Flycatcher compiler
-
intcode_compiler
AoC 2019 Intcode compiler, interpreter and transpiler
-
oxerun
Compiler bits to create Rust unikernels for Xen
-
tools_core
Core functionality and schema generation for the tools collection system
-
blink_core
Core interpreter for the Blink Lisp dialect
-
lora-compiler
Query-plan compiler for LoraDB's Cypher implementation
-
mica-std
The standard library of Mica, a simple, user-friendly, embeddable scripting language
-
wrecc_compiler
used by wrecc to compile C99 to x86-64
-
pk_parser
The Palacinke lang parser
-
tiny_lang_parser
A tiny language parser and interpreter for simple math expressions
-
bif
Brainfuck Compiler
-
lib-ruby-parser-ast
AST for lib-ruby-parser
-
pk_compiler
The Palacinke lang bytecode compiler
-
code_highlighter
Highlights code for printing
-
monkeyinterpreter
An interpreter written in Rust for the monkey programming language described in the book 'Writing An Interpreter In Go' (https://interpreterbook.com/)
-
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!
-
bsharp_interp
The B# programming language!
-
pulley-interpreter
The Pulley interpreter, its bytecode definition, encoder, decoder, and etc
-
bsharp
The B# programming language!
-
cbqn-sys
FFI bindings to CBQN
-
crispy
a lisp enterpreter
-
ezjs
micro Javascript (ES5) engine is Rust
-
ablescript
The best programming language
-
rcc4r
C compiler implemented in Rust with only 4 raw-functions
-
starfish
*><> is a stack-based, reflective, two-dimensional esoteric programming language based directly off of ><>
-
sqry-lang-ruby
Ruby language plugin for sqry
-
genotype_runtime
Genotype runtime
-
stir
Small Threaded Intermediate Representation
-
rusty_utils
package that provides utility functions inspired by or ported from other programming languages
-
logicaffeine-lsp
The LOGOS language server (LSP): diagnostics, completion, hover, navigation and refactoring for .lg files, literate .md files and LGX pages
-
petr-ir
target agnostic IR for the petr language
-
luah
Unofficial lua impl by HydroRoll-Team
-
genotype_lang_core_codegen
Genotype language target codegen crate
-
rustpython-parser
Python language parser for Python3
-
nlcc
Nameless C Compiler
-
leo-errors
Errors for the Leo programming language
-
ingot-language-service
Editor-facing analysis for Ingot: the diagnostics, hovers and symbols an editor shows, from the same compiler the CLI runs
-
litto
Building blocks for DSL scripting language interpreters that interact with native Rust code
-
libwild
that provides a fast linker for Linux and WebAssembly
-
eirproject/libeir_syntax_core
Erlang ecosystem common IR
-
xassembler
Compiler tools for the xasm programming language
-
mica-hl
High-level interface to the Mica scripting language
-
psilva_functions
Bibliotetca de funções do Psilva
-
rtlola-streamir-interpreter
An interpreter for RTLola through StreamIR
-
air-types
Types for the TNJ Assembly Intermediate Representation (AIR)
-
orion_lib
parsing and executing the Orion Programming Language
-
luar
Lua interpreter implemented in Rust
-
ratel
JavaScript transpiler in Rust
-
luajit2-sys
LuaJIT-2.1 FFI Bindings
-
rustpython-pylib
A subset of the Python standard library for use with RustPython
-
swamp-source-map
Source map cache for Swamp
-
tale
A Scripting language for TTRPG Tables
-
depyler-core
Core transpilation engine for the Depyler Python-to-Rust transpiler
-
lisper
Lisp interpreter in Rust
-
polonius
Core definition for the Rust borrow checker
-
stationeers-mips
Intermediate representation for Stationeers MIPS assembly
-
sateko
A toy brainfuck compiler
-
ptoxide
A virtual machine to execute CUDA PTX without a GPU
-
logo-runtime
Implements the runtime for graphic functionality of Logo programming language
-
vermilion-vm
A virtual machine written in Rust
-
finlang-core
A deterministic financial programming language with a typed compiler, verified bytecode VM, financial execution semantics, policies, and zero-knowledge proof support
-
genotype_lang_ts_codegen
Genotype language TypeScript target codegen crate
-
rustd_backend_llvm
LLVM backend for RustD deterministic DSL compilation
-
ano_jit_bfi_rs
Outdated Just-In-Time BrainFuck Interpreter written in RuSt
-
clue_core
C/Rust like programming language that compiles into Lua code
-
stainless_script
Visual node-based programming language
-
air-script-core
Core types for the AirScript compiler
-
artlr_syntax
syntax analysis
-
xur
programming language: run and inspect .xur programs
-
satellite-jit
LLVM JIT compilation for ABI-OP constraints
-
rigz_vm
Stack based VM for rigz
-
trustme
Tell the compiler that you can be trusted to write unsafe code!
-
jit_rs
jit.rs is a library for generating, optimizing and running executable code at runtime
-
diatom-std-os
The diatom programming language
-
clear-cache
A native implementation of
__builtin___clear_cachewithout dependency of GCC/Clang -
gibberish-core
Core types and functions for Gibberish parsers
-
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
-
petr-bind
The binding stage of the petr compiler
-
aivm
Artificial intelligence that embraces the hardware it runs on
-
oxc-graphql-parser
Spec-compliant GraphQL parser
-
gluac-rs
compiling Garry's Mod Lua into bytecode
-
bril-frontend
AST and type-checking for Bril programs
-
rust--
Turn Rust into C++
-
simple-vm
bytecode VM with a custom compiler
-
pk_vm
The Palacinke lang bytecode virtual machine
-
sonatina-parser
Parser for sonatina-ir text format
-
mica-language
Reference implementation of the Mica scripting language
-
ubpf-assembler
eBPF assembler and JIT compiler for ubpf
-
bsharp_tokens
The B# programming language!
-
rlisp
experimental lisp interpreter in rust
-
yagbas_asttypes
Abstract Syntax Tree type (and parser) for yagbas
-
blitz_lang
A Hobby Programming Lang with Rust
-
hzlang_parser
A parser for the "hz" programming language
-
yggdrasil-error
Yggdrasil shared error handlers
-
oil-lang
OIL
-
c64-assembler-6502
Definition of 6502 instruction set
-
rustyscript
Effortless JS Integration for Rust
-
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:… -
kaon
A little scripting language written in rust
-
citadel-api
The api for the citadel compiler backend
-
mlua-xid
A Rust-native binding for the 'xid' crate for Rust
-
cowlang
Python-like scripting language
-
surplus-cli
CLI for the Surplus JSX compiler
-
tenda-reporting
Reporting utilities for the Tenda programming language
-
simple-script-compiler
A tiny simple script language compiler/interpreter for learning and testing
-
toylang
CLI/Wrapper
-
diatom-cli
The diatom programming language
-
hlvm
/ tools
-
bicycle_compiler
A compiler for Pauli-based compilation (PBC) circuits to bicycle instructions
-
chan-lang
Chan Programming Language
-
runmat-lexer
Lexer for the RunMat language (MATLAB/Octave syntax) built with logos
-
regorus
A fast, lightweight Rego (OPA policy language) interpreter
-
celestial-hub-compass
ETAC compiler
-
bsharp_fset
The B# programming language!
-
xrcf
eXtensible and Reusable Compiler Framework
-
libsix
Compact programming language built on top of Rust ecosystem
-
numeron
Neron is a language designed to be as simple as possible
-
petr-profiling
tools for profiling the performance of the petr compiler
-
sylt-machine
VM for running programs in the Sylt programming language
-
genotype_lang_ts_converter
Genotype language TypeScript target converter crate
-
metals
A meta programming language for Composable Systems
-
sv-lang
Safe, ergonomic Rust bindings to slang, the fast SystemVerilog compiler frontend
-
roto
a statically-typed, compiled, embedded scripting language
-
swc_ecma_react_compiler
SWC helpers for the React Compiler
-
wedpr_ffi_macros
WeDPR ffi shared macros
-
aprender-verify-ml
Synthetic Data Factory for Domain-Specific Code Intelligence
-
llir
LLVM IR Binding
-
neptune-lang
An embeddable scripting language
-
ape_errors
error handlers for Aperture programming language
-
symboscript-utils
SymboScript utils
-
cxx-llvm-build
Common build code for cxx-llvm
-
lia-plugin
Compiler plugin for writing Lia code as a macro
-
sqry-classpath
JVM classpath analysis for sqry - bytecode parsing, build system resolution, and graph integration
-
gnulightning-sys
Rust bindings for gnulightning jit compiler
-
nodarium_utils
A collection of utilities for Nodarium
-
bsharp_parser
The B# programming language!
-
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
-
symboscript-interpreter
SymboScript interpreter
-
rascal_scanner
Rascal programming language scanner
-
ion-derive
Derive macro for Ion scripting language host types
-
swc_experimental_ecma_parser
An extensible Rust-based platform for the next generation of fast developer tools
-
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… -
rlvm
LLVM wrapper
-
llvm-sys-wrapper
Shallow wrapper for llvm-sys
-
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… -
orecc-front
compiler frontend utility toolkit
-
carlo-help
A help utility for the simple interpreted programming language Carlo
-
carlo-version
Version for the simple interpreted programming language Carlo
-
kernite-core
A kernel as instructions over registers
-
carlo-run
A runner for the simple interpreted programming language Carlo
-
swc_ecma_transforms_proposal
rust port of babel and closure compiler
-
carlo-repl
A REPL for the simple interpreted programming language Carlo
-
tenda-parser
Parser for the Tenda programming language
-
crain
A Brainfuck compiler/interpreter/tool
-
request_compiler
Request Compiler Optimized for Batching Requests
-
vermilion_jit
A toolkit for JIT compilation
-
syntax-rs
parsing programming languages
-
rascal_bytecode
Rascal programming language bytecode
-
regen-lang
A language for defining languages
-
tt-toolkit
A collection of macros for rapidly prototyping programming languages
-
vm_lang
interpreted language written in Rust
-
cte_ir
Compile-time evaluation IR
-
gladiator
A concurrent, modular and small garbage collector
-
rust-codegen
builder API for generating Rust code
-
noxue-compiler
利用docker实现在线编译运行代码
-
bsharp_bstar
The B# programming language!
-
ils
Directly read directory in image files
-
whenever-parser
A parser for David Morgan-Mar's Whenever language (http://www.dangermouse.net/esoteric/whenever.html)
-
go-engine
The wrapper of the Goscript project
-
swc_es_codegen
High-performance code generator for swc_es_ast
-
w16-ir
Промежуточное представление w16, и оптимизации
-
rascal_parser
Rascal programming language parser
-
badeline-plugin
Darkside reflection for Rust
-
extern-existential
Rust extern existential types prototype
-
mtots
scripting language
-
enalang
Exhaustingly Notorious Algorithms - umbrella package
-
lucia-lang
Lucia programming language
-
rustc_utils
working with the Rust compiler
-
norn
High-level compiler library
-
remarklib
The core of the Remark programming language
-
rustc_get_version
rust compiler get version utility
-
swc_compiler_base
Base crate for the 'swc' crate. This is not a public API.
-
lib_stacked
Virtual Machine Byte Code For Compilers
-
catalyst_entities
Low level data-structures for multithreaded and incremental compilation
-
llvm-ir-taint
Taint tracking for LLVM IR
-
kind-query
Query module for the kind compiler
-
mir-sys
FFI bindings to MIR Project (https://github.com/vnmakarov/mir)
-
unfuck
Python 2.7 bytecode deobfuscator
-
px-llvm-codegen-utils-core
Core traits for LLVM codegen utilities
-
golang-type
Golang Type
-
orbitc
The Orbit Compiler Infrastructure
-
flycatcher-parser
The Flycatcher programming language's parser
-
lovm2_error
a lightweight virtual machine with a focus on simplicity and extendability
-
cargo_experiment_c
experiment with cargo
-
polyglot_tokenizer
A generic programming language tokenizer
-
bytebraise-syntax
BitBake parsing, syntax, and AST definitions for bytebraise
-
celox-test-suite-veryl
Reusable Veryl language tests for compiler and simulator implementations
-
c-lang
Scripting language made in rust
-
rolldown_ecmascript
ECMAScript AST and parsing utilities for Rolldown
-
bf
An optimizing Brainfuck interpeter and JIT compiler
-
test_zia
Test Library for the Zia Programming Language
-
iaith
Implementing toy languages in rust
-
haloumi-ir-base
Types used by the IR and by some modules that the IR depends on
-
comment
Strip comments for multiple programming languages
-
lwb-parser
parser framwork with automatically generated ASTs for the LWB project
-
cxx-llvm-build-common
Common build code for cxx-llvm and dependent crates
-
coopted_llvm_sys
Coöpt rustc‘s own LLVM to do fancy stuff with it
-
shulkerscript
language implementation with compiler
-
toyc
The toylang compiler
-
helen-ffi
Helen language Rust reimplementation — helen-ffi (M10 Python FFI, Helen → Python)
-
sussy
pierwszy kwietnia
-
xlang_targets
ABI Safe Interfaces for target triples and discovering compiler-required information about targets
-
dylan
Dylan
-
the-super-tiny-rusty-compiler
A super tiny and rusty compiler
-
dibs-qgen
Query DSL code generator for dibs (parses .styx query files into Rust and SQL)
-
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
-
ruschm
Scheme(R7RS-small) interpretor/compiler rust implementation
-
koi-lang
🐟 High-level programming language 🐟 Cross-platform 🐟 Blazing performance 🐟 Static linking 🐟
-
rustycli
🦊 Access the rust playground right in terminal
-
molt-ng
Embeddable TCL interpreter for Rust applications ()
-
xasm
Compiler for the xasm programming language
-
robson_compiler
Dependency of the robson cli
-
sylt-typechecker
Typechecker for programs in the Sylt programming language
-
ppppp
Test
-
kast
kast programming language
-
molt-app
Molt Shell Application
-
ape_env
environments for Aperture programming language
-
mirrc
MIRR compiler — a safety-critical DSL for hardware-software co-design targeting SystemVerilog RTL
-
maroon
Scheme-inspired lisp that compiles to Lua
-
guile
Safe bindings to GNU Guile
-
easter
Type definitions for ECMAScript abstract syntax trees
-
dora-parser
The Dora programming language
-
ape_expr
abstract syntax tree for Aperture programming language
-
cpprs
C pre-processor on Rust source files
-
ncc
Compiler for custom modes on Novation MIDI devices
-
hbc
Random program that does random stuff
-
skrusty
Translating C to Rust
-
gitrevset
A domain-specific-language to select commits in a git repo. Similar to Mercurial's revset.
-
swc_ecma_transforms_react
rust port of babel and closure compiler
-
h2lang
H2 Language - A Herbert Online Judge compatible programming language with multi-agent support
-
vicuna-runtime
Runtime for the Vicuna programming language
-
luaparser
Read Lua 5.1 code and produce an abstract syntax tree
-
cemc
Cem language compiler - A concatenative language with green threads and linear types
-
intent-runtime
Expression evaluator and stateless runtime for IntentLang specifications
-
crispr_guessing_game
My first small rust project
-
wmlua-src
wmlua
-
scurry
A component-based object-oriented language
-
syntactic_heap
A framework designed for representing Abstract Syntax Trees
-
ial-ast
ial's Abstract Syntax Tree
-
welly-parser
An artisanal parser for the Welly programming language
-
fervid
Vue SFC compiler written in Rust
-
demi
An interpreter for the Demi programming language
-
dimpact
impact analysis from diff
-
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. -
trashcan
language which compiles to Visual Basic 6 / VBA
-
ontomark-compile
Compile Markdown ontology vaults to RDF 1.1 Turtle, JSON-LD 1.1, SHACL, NGG1 graph tiers and page APIs under a versioned profile
-
tan-lang
namespace for tan-lang.org crates
-
yagbas_srcfiletypes
types for reading in yagbas source files
-
evscript
An extensible bytecode-based scripting engine
-
sljit-sys
System crate for sljit using bindgen and ast-grep
-
vicuna-compiler
A compiler for the Vicuna programming language
-
xlang-syntax
The xlang parser and syntax utilities
-
maat_field
Finite field arithmetic and value-to-field encoding for the Maat programming language
-
wasmer-clif-fork-simplejit
JIT library backed by Cranelift
-
tanlang
namespace for tanlang-org crates
-
rainlang_dispair
Rainlang DISPaiR Rust Crate
-
fck
Brainfuck parser, lexer and interpreter
-
rji
Generates an efficient and seamless Rust/Java bridge. A Rust-Java Interface.
-
flowlog-parser
Parser and typechecker for the FlowLog Datalog language
-
boolfuck
unoptimized boolfuck interpreter which can convert brainfuck code
-
laburnum-syntax-macro
Proc-macros for defining CST and AST node types in language frontends built with the laburnum LSP framework
-
arbor-core
AST parsing and code analysis for Arbor
-
cranelift-module
Support for linking functions and data with Cranelift
-
kind-report
Report module for the kind compiler
-
onlang
A programming language running on json or yaml
-
enalang_vm
Exhaustingly Notorious Algorithms - virtual machine
-
rust-visitor
Visitor trait for Rust AST based on rust-analyzer
-
yeller
The best programming language ever
-
eridani
Pure functional scripting, anywhere
-
rascal_vm
Rascal programming language virtual machine
-
sloppy
A binary package to run sloppy script
-
genotype_lang_rs_converter
Genotype language Rust target converter crate
-
ljf
tutorials
-
boa_ast
Abstract Syntax Tree definition for the Boa JavaScript engine
-
rust-compile
Go on. Compile it.
-
open-vaf
A compiler frontend for VerilogA aimed predominently at compact modelling
-
vk_execute_compiler
VK execute compiler
-
galvan-parse
The parsing crate for the compiler of the Galvan programming language
-
meadorc
meador scripting language compiler
-
spade-types
Helper crate for https://spade-lang.org/
-
gccarch
Report architecture information from GCC's backends list
-
progenitor-hk
An OpenAPI client generator
-
moore-circt-sys
Low-level language bindings to CIRCT
-
crisp-runtime
A small, expressive Lisp-inspired programming language
-
new_project
Basic math operations
-
ryna-ffi
FFI interface for the Ryna Programming Language
-
logo-web
Web-based IDE for Logo programming language
-
js_parser
Javascript Parser : generate Aleph Syntax Tree
-
kodept
compiler with dependent types support in mind
-
rubble-templates-evaluators
A set of parsers, evaluators and compilers for text templates
-
mini-lang
A minimal, experimental language for lazy evaluation
-
tidepool-eval
Tree-walking interpreter for Tidepool Core
-
guile-scheme
A small wrapper around the Guile Scheme Extension and Scripting Language
-
litelite
A kit for purpose-sized languages: buy total verification with smallness. Diagnostics, lexing, parsing, fuel, and capability tables — the invariants paid once.
-
alder-source
Source AST for the alder programming language
-
App1
A sample Rust library project
-
cfg_compiler
cfg setup
-
wirespec
Type-safe protocol description language — compiler, verifier, and LSP
-
avdl
Avro IDL compiler that turns .avdl into .avpr and .avsc JSON files
-
koi-parser
koi programming language parser
-
papyri-lang
Compiler for the Papyri markup language
-
stap-lang
Stap programming language (STAck Processor, ala Lisp)
-
rascal_compiler
Rascal programming language compiler
-
dpy
transpiler to translate dutch python like code to working python code
-
quail
Programming Language
-
petr-resolve
resolution stage of the petr compiler
-
fervid_core
The core structures and utilities of fervid
-
hush
unix shell scripting language based on the Lua programming language
-
lora-analyzer
Semantic analysis for parsed Cypher queries in LoraDB
-
my_project0
-- log 0.4.* (test0 0.2.0)
-
tenda-scanner
Scanner for the Tenda programming language
-
petr-cli
command line tool for compiling petr code
-
enalang_compiler
Exhaustingly Notorious Algorithms - compiler
-
kotlin-parser
Kotlin Language Parser (WIP)
-
dotzuki-engine-dsl
Game DSL compiler (.scene/.gui/.theme/.style) plus a native AST interpreter for the dotzuki JRPG engine
-
paxforth
Pax Forth programming language for Pax Consola, a development environment for vintage computers and consoles
-
trogdor
Error handling for programming languages
-
graphcal-ast-derive
Type-safe, unit-aware, Git-friendly reactive programming language for engineering calculations
-
nodespeak
A JIT-ish compiler for number-crunching applications
-
ffmmlc
FFMML command-line compiler
-
vize_relief
Relief - The sculptured AST surface for Vize Vue templates
-
intent-parser
PEG parser and typed AST for the IntentLang specification language
-
euphony-compiler
compiler infrastructure for euphony compositions
-
molt-argparse
The argument parser generator macro for the Rust-based Tcl interpreter, Molt
-
petr-typecheck
the typecheck stage of the petr compiler
-
mallardscript
Hak5 DuckyScript extended language compiler
-
as3razen
compiler
-
diatom-core
The diatom programming language
-
melbi
expressive, embeddable, sandboxed expression language
-
teolang
A programming language design to be easy to learn for kids
-
reproto
compiler
-
evcxr_jupyter
A Jupyter Kernel for Rust
-
ux-compiler
UX Framework Complier
-
reic
A compiler that just works
-
swc_ecma_transforms_compat
rust port of babel and closure compiler
-
zkpyc-stdlib
Standard library for the ZKPyC compiler
-
abstraps
Extensible compiler middle layer with abstract interpretation and code generation to MLIR
-
libjay
Independent, modern implementations of the J and APL array languages: parallel and vectorized, embeddable from Rust, Python, and C
-
cgp
A language extension for Rust, with pluggable trait implementations at compile-time
-
loxcraft
A compiler, VM, language server, and online playground for the Lox programming language
-
ampc
Compiler for the Amp language
-
lib-zinc
Standard library for Zinc Programming Language
-
dora
programming language
-
tenda-common
Common utilities for the Tenda programming language
-
lulz
A fast and spec-compliant LOLCODE implementation
-
cjc-diag
Diagnostic infrastructure and error codes for CJC
-
riscv_analysis_cli
RISC-V static analysis tool -- CLI
-
llvm-wrapper
Safe llvm-sys wrapper
-
crush-pkg
Crush language package manager — cargo-like build tool for Crush programs
-
runtime-lexer
regex based lexer
-
huam-rust-utils
这是一个用于学习rust的工具库,记录一些常用的工具函数
-
kasl
Parses and translates the kasl code into KASL-IR, an intermediate representation for KASL
-
lunir
A universal intermediate representation oriented towards Lua
-
brainfrick
An optimizing brainfuck interpreter with helpful errors
-
rscmm
C-interpreter
-
synth-cli
CLI for Synth, the WebAssembly-to-ARM Cortex-M AOT compiler
-
charon_ariadne
A fancy diagnostics & reporting crate - resigned for crates.io/charon
-
modelx
Compiler for Modelx files
-
bitwright
Hash-consed fixed-width bit-vector expressions: exact evaluation, bit-level facts, and verified simplification
-
golang-type-name
Golang TypeName
-
logo-interp
Implements parsing and interpreting of Logo programming language
-
petr-utils
common utilities for the petr compiler and tooling
-
rsaeb
A no_std + alloc interpreter for A=B ordered rewrite programs
-
swc_ecma_transforms_optimization
rust port of babel and closure compiler
-
cardinal-c
A C target for the Cardinal code generator
-
eirproject/libeir_intern
Erlang ecosystem common IR
-
rustycpp
An attempt to implement the C++20 standard. This is mostly to have fun & learn rust
-
moonlift
A pure-rust implementation of Lua (5.4) with just-in-time (JIT) compilation using
cranelift -
fbp
Flow Based Programming for the Rust language
-
bdwgc-sys
Boehm-Demers-Weiser garbage collector bindings for Rust
-
bfcomp
A compiler for BrainF*ck implemented with AWIB and bfcore
-
quicklatex
A program to help me write LaTeX quickly
-
rspack
-
swc_next_core_bridge
An extensible Rust-based platform for the next generation of fast developer tools
-
riscv_analysis
RISC-V static analysis tools
-
ffi_reflect_csharp
C# code generator for the
ffi_reflectpackage -
lift-config
LIFT compiler configuration: .lith language parser and validator, O0-O3 optimisation pipeline presets
-
chomatter_cli
Compiler for the language
-
julia
Idiomatic and safe Julia bindings for Rust
-
ric-engine
Rust Interactive Console
-
quickjs-rusty
QuickJS (QuickJS-NG) Javascript engine wrapper, and more
-
neyuki
A small Lua-like scripting language implemented in Rust
-
sylt-common
Common denominator for the Sylt programming language crates
-
kbvm-cli
A CLI for working with XKB
-
metaltile-macros
Proc-macro crate providing the #[kernel] DSL for MetalTile GPU kernels
-
inline-python
Inline Python code directly in your Rust code
-
tylisp
A domain-specific language for expressing complex type bounds
-
bork
Pretty print syntax errors for your parser or interpreter
-
quickscript
A quick programming language with a compiler implemented in Rust