-
rustc-demangle
Rust compiler symbol demangling
-
ariadne
A fancy diagnostics & reporting crate
-
tree-sitter
Rust bindings to the Tree-sitter parsing library
-
boa_engine
Boa is a Javascript lexer, parser and compiler written in Rust. Currently, it has support for some of the language.
-
rquickjs
High level bindings to the QuickJS JavaScript engine
-
llvm-sys
Bindings to LLVM's C API
-
ena
Union-find, congruence closure, and other unification code. Based on code from rustc.
-
apollo-parser
Spec-compliant GraphQL parser
-
oxc
A collection of JavaScript tools written in Rust
-
melior
The rustic MLIR bindings in Rust
-
jaq-interpret
Interpreter for the jaq language
-
demand
A CLI prompt library
-
rustlr
Bottom-Up Parser Generator with Advanced Options
-
c2rust
C to Rust translation, refactoring, and cross-checking
-
rustpython
A python interpreter written in rust
-
boa_string
Boa is a Javascript lexer, parser and compiler written in Rust. Currently, it has support for some of the language.
-
mago-docblock
Analyzes PHP docblocks to extract annotations, tags, and documentation comments, aiding tools that rely on inline documentation
-
apollo-compiler
A compiler for the GraphQL query language
-
cel
A parser and interpreter for the Common Expression Language (CEL)
-
sus_compiler
Compiler for the SUS Hardware Design Language
-
cranelift-frontend
Cranelift IR builder helper
-
tree-sitter-language-pack
Core library for tree-sitter language pack - provides compiled parsers for 306 languages
-
egglog
language that combines the benefits of equality saturation and datalog. It can be used for analysis, optimization, and synthesis of programs. It is the successor to the popular rust library egg.
-
fucker
BrainFuck interpreter and optimizing JIT compiler
-
rolldown-ariadne
A fork of github.com/zesterer/ariadne
-
rustpython-compiler
A usability wrapper around rustpython-parser and rustpython-compiler-core
-
typst-assets
Assets for the Typst compiler
-
rune
Language, an embeddable dynamic programming language for Rust
-
clang
A somewhat idiomatic Rust wrapper for libclang
-
gccjit
Higher-level Rust bindings for libgccjit
-
pluto-lang
A interpreted programming language made in Rust
-
starlark
language in Rust
-
leo-parser-rowan
Rowan-based lossless parser for Leo
-
rilua
Lua 5.1.1 implemented in Rust, targeting the World of Warcraft addon variant
-
spirt
Shader-focused IR to target, transform and translate from
-
erg
programming language
-
dynasmrt
runtime for assembling code at runtime. Combined with the plugin crate dynasm it can be used to write JIT compilers easily.
-
adana
namespaces aliases for command lines & basic scripting language
-
steel-core
Core compiler and VM implementation for steel
-
hstr
A string type which is optimized for hash operations
-
python-rs
A stackless Python 3 interpreter written in Rust — academic/hobby AI-assisted port of CPython. Pre-release; not usable yet.
-
jstime
JS Runtime
-
typespec_client_core
Client runtime for TypeSpec-generated libraries
-
miden-project
Interface for working with Miden projects
-
tket
Quantinuum's TKET Quantum Compiler
-
spirv-cross2
Safe Rust bindings to SPIRV-Cross
-
cranelift-native
Support for targeting the host with Cranelift
-
nagami
Shrinks WGSL shaders via Naga IR optimization passes
-
boa_parser
ECMAScript parser for the Boa JavaScript engine
-
rustc-build-sysroot
Build a rustc sysroot with custom flags
-
garnish_lang_compiler
Utilites to compile garnish scripts
-
firmion
Ergonomic firmware and binary file creation tool
-
hvm
A massively parallel, optimal functional runtime in Rust
-
harn-parser
Parser, AST, and type checker for the Harn programming language
-
mago-syntax
A correct, fast, and memory-efficient PHP syntax implementation, including Lexer, Parser, AST, and utilities for Mago
-
sqry-lang-kotlin
Kotlin language plugin for sqry
-
decy-hir
High-level Intermediate Representation for C-to-Rust transpilation
-
frg
Compiled programming language with frogs!
-
typst-pdf
PDF exporter for Typst
-
diplomat
FFI generation macro
-
axon-lsp
Language Server Protocol server for the Axon programming language. Deterministic diagnostics, hover, completion, and go-to-definition across VSCode, Claude Code, Cursor, Antigravity…
-
obeli-sk-boa-ast
Abstract Syntax Tree definition for the Boa JavaScript engine
-
lex-types
Type system + effect inference for Lex
-
swc_ecma_transforms_base
rust port of babel and closure compiler
-
chap
easy to learn, interpretive, scripting language written in Rust
-
fusevm
Language-agnostic bytecode VM with fused superinstructions and a 3-tier Cranelift JIT (linear/block/tracing)
-
ternpkg
Package manager for the ternlang ecosystem — ternlang.toml manifest, GitHub-backed registry, install/list/info commands
-
vrl
Vector Remap Language
-
airlang
Air is a universal, reliable, and lean programming language
-
luars
lua 5.5 runtime implementation in Rust
-
cljrs-ir
Intermediate representation types for clojurust compiler and interpreter
-
acir_field
The field implementation being used by ACIR
-
codesnake
Pretty printer for non-overlapping code spans
-
tishlang_compile
Tish native compiler backend
-
cxxbridge-flags
Compiler configuration of the
cxxcrate (implementation detail) -
dylint-link
A wrapper around Rust's default linker to help create Dylint libraries
-
keleusma
Total Functional Stream Processor with definitive WCET and WCMU verification, targeting no_std + alloc embedded scripting
-
rustc_utils
working with the Rust compiler
-
slicec
The Slice parser and other core components for Slice compilers
-
rustc-std-workspace-core
integration of crates.io crates into rust-lang/rust standard library workspace
-
logicaffeine-compile
LOGOS compilation pipeline - codegen and interpreter
-
rustc_version_runtime
querying the version of the rustc compiler used in runtime
-
lambda_mountain
Typed Macro Assembler (backed by Coq proofs-of-correctness)
-
ferrugocc
An experimental C compiler and obfuscating compiler written in Rust, targeting x86_64 SysV ABI
-
lady-deirdre
Compiler front-end foundation technology. Main Crate.
-
forgellm-cli
CLI tool for the ForgeLLM compiler
-
kz80_lisp
A minimal LISP interpreter and compiler for RetroShield Z80
-
heraclitus-compiler
Compiler frontend for developing great programming languages
-
chalk-ir
Chalk's internal representation of types, goals, and clauses
-
from-pest
Convert from a pest grammar to a typed AST
-
run
a.k.a. runtool: the bridge between human and AI tooling
-
cranelift-codegen
Low-level code generator library
-
haskelujah
A Haskell compiler in Rust — GHC-compatible, self-contained, faster than GHC
-
bop-lang
A small, embeddable, dynamically-typed programming language with zero dependencies
-
atlas_77
Wannabe systems programming language
-
rumoca
Modelica compiler written in RUST
-
xdy
Complex RPG dice expression evaluator with histogram support
-
nectar-lang
A compiled-to-WASM frontend language with built-in security, SEO, and mobile support
-
qala-cli
Command-line interface for the Qala programming language
-
jsonpiler
a Json syntax programming language for Windows
-
onion-lang
A modern functional programming language with asynchronous execution and lazy evaluation
-
typeset
A DSL for defining source code pretty printers
-
pliron
Programming Languages Intermediate RepresentatiON
-
tetherscript
A dynamically-typed scripting language with Rust-style ownership, implemented as a bytecode VM in Rust
-
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.
-
calcit
Interpreter and js codegen for Calcit
-
cljrs-reader
Lexer and parser producing Form AST nodes for clojurust
-
scryer-prolog
A modern Prolog implementation written mostly in Rust
-
delo
A statically typed, compiled-to-C programming language that can time-travel
-
gust-cli
The Gust compiler CLI — compile .gu state machine files to Rust, Go, WASM, no_std, or C FFI
-
three_body_lang
Three Body Language written in Rust
-
pandora-interpreter
A command-line tool to run pandora language
-
oxc_parser
A collection of JavaScript tools written in Rust
-
sora-codegen
powerful configuration table compiler for games and data-heavy tools
-
graphcal
Type-safe, unit-aware, Git-friendly reactive programming language for engineering calculations
-
php-rs-parser
Fast PHP parser producing a typed AST
-
leo-abi
ABI generation for Leo programs
-
wadl
parser for Rust
-
maat
programming language -- Rust-native syntax for writing zero-knowledge proofs
-
stak-vm
Virtual machines for Stak Scheme
-
midenc-log
flexible trace logging for midenc
-
tyre-t
T compiler CLI
-
rhai-loco
Rhai scripting engine integration for Loco
-
zetac
The final systems language
-
clue
C/Rust like programming language that compiles into Lua code
-
rustpython-codegen
Compiler for python code into bytecode for the rustpython VM
-
cudaforge
Advanced CUDA kernel builder for Rust with incremental builds, auto-detection, and external dependency support
-
alephc
Aleph Compiler (or transpiler)
-
atc-router
Versatile DSL based rule matching engine used by the Kong API Gateway
-
tulisp
An embeddable lisp interpreter
-
lamina
High-performance compiler backend for Lamina Intermediate Representation
-
node_resolver
Node.js module resolution algorithm used in Deno
-
asc_bin
An automated C/C++ package manager, source code scanner, and builder that streamlines dependency management, enhances code analysis, and simplifies the build process
-
mimium-lang
mimium(minimal-musical-medium) an infrastructural programming language for sound and music
-
tl-parser
Recursive descent parser for ThinkingLanguage
-
tidepool-repr
Intermediate representation for the Tidepool compiler
-
teacat
A modern document languge for web pages
-
formalang
compiler frontend: lexer, parser, semantic analyzer, and IR lowering
-
semantic-analyzer
Semantic analyzer library for compilers written in Rust for semantic analysis of programming languages AST
-
syn-locator
A source mapper for syn syntax trees
-
runmat-gc-api
Public API types for the RunMat garbage collector
-
packtab
Pack static integer tables into compact multi-level lookup tables
-
cranelift-jit
A JIT library backed by Cranelift
-
pipeline-script
Script engine designed for the project construction tool pipeline(crate name pipeline-cli)
-
gluon_vm
The virtual machine for executing the gluon programming language
-
cedar-policy-symcc
Symbolic Cedar Compiler (SymCC): translates queries about Cedar policies to SMT
-
lisette
Little language inspired by Rust that compiles to Go
-
mago-type-syntax
core utilities useful for building lexers and parsers within Mago
-
rajac
Command-line interface for the rajac Java compiler
-
wdl-ast
An abstract syntax tree for Workflow Description Language (WDL) documents
-
sqry-lang-java
Java language plugin for sqry
-
vize_relief
Relief - The sculptured AST surface for Vize Vue templates
-
soppo
Compiler for Soppo, a Go superset with enums, pattern matching, and nil safety
-
nyxstone
Bindings for the nyxstone assembler/disassembler
-
zapcode-core
A minimal, secure TypeScript subset interpreter — parse, compile, execute, snapshot
-
rspack_plugin_rsc
Rspack React Server Component plugin
-
fsqlite-planner
Query planner: name resolution, WHERE analysis, join ordering
-
metaslang_stack_graphs
Stack graphs utilities used in Slang
-
phper
The framework that allows us to write PHP extensions using pure and safe Rust whenever possible
-
yulang
Experimental language with Simple-Sub-style inference, algebraic effects, effect rows, roles, and Ruby/Perl/Raku-inspired syntax
-
cljrs-eval
IR-accelerated evaluation for clojurust (tier-1 IR interpreter + lowering)
-
hsml
A pug-inspired HTML preprocessor
-
vexilc
The Vexil schema compiler CLI
-
dust_dds_gen
OMG IDL compiler for Dust DDS
-
rustcc
An little C Complier( now it's just WIP :) )
-
tinymist-assets
assets for tinymist
-
gabelang
A high level, interpretted and garbage collected programming language
-
airl-cli
Command-line interface for AIRL: run, compile, type-check, patch, REPL, HTTP API
-
blisp
A lisp like statically typed programing language for no_std
-
neorusticus
A Prolog implementation in Rust with enhanced error handling
-
quickjs_runtime
Wrapper API and utils for the QuickJS JavaScript engine with support for Promise, Modules, Async/await
-
stack-assembly
minimalist, stack-based, assembly-like programming language
-
llvm-in-rust-ir
Core LLVM-inspired intermediate representation data structures and builders for LLVM-in-Rust
-
firmion-layout-phase
Layout phase used by the firmion compiler
-
diplomat-runtime
Common runtime utilities used by diplomat codegen
-
kn-cuda-eval
A CUDA executor for neural network graphs
-
beamr
runtime with the BEAM's execution model, targeting Gleam
-
faye
a pretty lil lisp
-
libcint
FFI binding and GTO wrapper for libcint (C library)
-
hi-doc
Diagnostics formatting library
-
hugr-passes
Compiler passes for Quantinuum's HUGR
-
vplsfpoael
the best programming language (joke)
-
rune_c_compiler
A Rune to C source file compiler
-
starter-shell
A starting shell for any application
-
antimony-lang
The Antimony programming language
-
lustc
A Lean4 subset to Rust source-to-source compiler
-
glt
Glint compiler library
-
deno_webidl
WebIDL implementation for Deno
-
uiua
A stack-based array programming language
-
aver-lang
VM and transpiler for Aver, a statically-typed language designed for AI-assisted development
-
runar-compiler-rust
Rúnar compiler (full pipeline: .runar.ts → Bitcoin Script)
-
whisper-lang
Whisper: a compact stack-based programming language for AI
-
wright
programming language compiler and tooling
-
glslang
Rust bindings to glslang
-
progenitor-middleware
An OpenAPI client generator
-
reluxscript
Write AST transformations once. Compile to Babel, SWC, and beyond.
-
bbnf-ir
Canonical Grammar IR for the BBNF compiler pipeline
-
t-parser_c
C-syntax parser for the T programming language
-
csml_engine
The CSML Engine is a conversational engine designed to make it extremely easy to create rich and powerful chatbots
-
pe-assembler
PE/COFF assembler for Windows instruction sets - strongly typed, object-oriented, zero-dependency core
-
generic-lang
A Lox based programming language
-
sbnf
A BNF-style language for writing sublime-syntax files
-
zust-compiler
Compiler front-end and semantic lowering for the Zust scripting language
-
atoxide-cli
Atopile compiler CLI
-
han-lang
한글(Han) Korean-syntax programming language: interpreter, LLVM-IR codegen, and LSP
-
ascent
Logic programming in Rust
-
urd
Dialogue scripting language for games — compiler, VM, and static analysis
-
webfluent
The Web-First Language — compiles to HTML, CSS, JavaScript, and PDF. 50+ built-in components, reactivity, routing, i18n, SSG, and template engine.
-
lang-util
implementing parsers and ASTs using lalrpop
-
spade-ast
Helper crate for https://spade-lang.org/
-
netsblox-ast
parsing NetsBlox project files into an AST for use in code generation
-
bicycle_random_numerics
Collect numerics for random Pauli-generated rotations run on the bicycle architecture
-
leo-disassembler
A disassembler for the Leo programming language
-
rs-runec
A RuneScript 2 Compiler and Linter Built Entirely in Rust
-
swc_ecma_transforms_typescript
rust port of babel and closure compiler
-
endbasic
programming language - CLI
-
intent-cli
CLI toolchain for IntentLang: check, render, compile, verify, audit, query, lock, fmt, generate, init
-
somni-parser
Grammar parser of the Somni language and VM
-
brainfoamkit
An interpreter for the brainf*** language
-
m68000
A Motorola 68000 interpreter, disassembler and assembler (code emitter)
-
mech-set
Set library for the Mech language
-
pyimports
Parse and analyze the imports within a python package
-
cargo-ats3
Cargo subcommand for ATS3 projects
-
hax-frontend-exporter
mirrors of the algebraic data types used in the Rust compilers, removing indirections and inlining various pieces of information
-
somatize-compiler
Graph-to-execution-plan compiler for the Soma runtime
-
ts-native
TypeScript to Native compiler
-
a2x
A converter from ALFA to XACML policy language
-
lamina-weld
weld - Cross-platform linker. Fast, minimal, drop-in for ld/lld/mold. Links ELF (Linux), PE (Windows), Mach-O (macOS).
-
steel-parser
Parser for use within steel
-
lower-ir-utils
Helpers for mapping Rust types to Cranelift JIT signatures, lowering call arguments, and reducing module boilerplate
-
garble_lang
Turing-Incomplete Programming Language for Multi-Party Computation with Garbled Circuits
-
infr
A gradually typed superset of R
-
st8
Stator JavaScript shell — interactive JS REPL and script runner (like V8's d8)
-
wesley-cli
Wesley native CLI
-
cyclang
toy language built in LLVM
-
tishlang_vm
Bytecode VM for Tish
-
ilo
token-minimal programming language AI agents write
-
haskelujah-driver
Compilation driver and project orchestration for the Haskelujah compiler
-
obeli-sk-boa-string
Boa is a Javascript lexer, parser and compiler written in Rust. Currently, it has support for some of the language.
-
metrowrap
A mwcc wrapper
-
oonta
OCaml (subset) to LLVM IR compiler front-end
-
oak-typescript
TypeScript frontend for Oak
-
lykn
A modern Lisp for ECMAScript, the browser, and the Deno JavaScript runtime
-
typst-render
Raster image exporter for Typst
-
bock-types
Type system, type checking, and inference for the Bock language
-
slac
The "Simple Logic & Arithmetic Compiler" transforms a single expression into an abstract syntax tree
-
Tres
Interpreter for the Tc2 esolang
-
plotnik-compiler
Compiler for Plotnik query language (parser, analyzer, bytecode emitter)
-
qala-compiler
Compiler and bytecode VM for the Qala programming language
-
cargo-abi-audit-cli
Cargo-native Rust/native ABI auditing CLI, scoped honestly to a C-ABI-first workflow
-
lua-cli
The lua-rs command-line interpreter: Lua 5.4 in safe Rust
-
type-bridge-core-lib
TypeQL AST, schema parser, query compiler, and validation engine for type-bridge
-
obeli-sk-boa-parser
ECMAScript parser for the Boa JavaScript engine
-
windy-lang
Windy — a 2D esoteric programming language where code flows like wind
-
xbasic64
A BASIC-to-x86_64 native code compiler targeting 1980s-era BASIC dialects
-
lua-rs-hlua-shim
Drop-in replacement for the
hlua0.4 embedding API, backed by the pure-Rust lua-rs VM. Lets hlua-based consumers (authoscope, sn0int) run on lua-rs behind a feature flag. -
tinymist
An integrated language service for Typst
-
monkey-parser
a parser for monkey lang
-
java_asm
Java bytecode reader & writer in rust
-
relon-cap
Leaf crate holding Relon's canonical capability data types (CapabilityBit / NativeFnGate / Capabilities)
-
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…
-
lolrust
A transpiler from .meow (lolcat Rust) to valid Rust. i can haz rust?
-
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
-
rapx
A static analysis platform for use-after-free, memory leakage detection, etc
-
lumen-compiler
The AI-Native Programming Language
-
nashc
Compiler for the nash programming language
-
stack-graphs
Name binding for arbitrary programming languages
-
rusty_lr
A Bison-like Parser generator & Compiler frontend framework for Rust generating IELR(1), LALR(1) parser tables, with deterministic LR and non-deterministic LR (GLR) parsing
-
procss
CSS parsing and transformation framework
-
llvm-ir
LLVM IR in natural Rust data structures
-
preinterpret
An intuitive toolkit to simplify code generation development
-
x86_64-assembler
Modern assembler for x64 and x86 instruction sets - strongly typed, object-oriented, zero-dependency core
-
boa-cat
Tree-walking ECMAScript interpreter built on ecma-syntax-cat. v0.7.0 bumps to ecma-parse-cat 0.3 so the async track’s tests can drop their
(async function () { ... })()IIFE workarounds and use natural `async ()… -
runmat-parser
Parser for RunMat (MATLAB/Octave) producing HIR from token streams
-
lmntalc
A compiler for the LMNtal language
-
rspack_plugin_rslib
Rslib native plugin
-
god-gragh
A graph-based LLM white-box optimization toolbox: topology validation, Lie group orthogonalization, tensor ring compression
-
decy-parser
C AST parsing using clang-sys for Decy transpiler
-
tatara-lisp
Homoiconic S-expression reader + macroexpander — the pleme-io Lisp authoring surface, hermetic-build standalone
-
verter_core
Vue 3 SFC compiler - transforms Vue Single File Components to render functions with TypeScript support
-
logicaffeine-language
Natural language to first-order logic pipeline
-
marigold
Programming Language
-
framec
Frame language transpiler — state machines that generate production code
-
dlwrap
dlopen wrapper code generator
-
polonius-engine
Core definition for the Rust borrow checker
-
galvan
A higher-level programming language that transpiles to Rust
-
naga-rust-back
Backend for the Naga shader translator which generates Rust code
-
rust_lisp
A Rust-embeddable Lisp, with support for interop with native Rust functions
-
uxn-tal
uxntal:// protocol | a Rust library for assembling TAL (Tal Assembly Language) files into UXN ROM files
-
ai-sentinel
Compilation wrapper used to fix misc compilations bugs
-
abrase
language
-
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
-
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
-
elworthy
JIT compiler that specialises Bismut-Elworthy-Li formulas into SIMD kernels for unbiased Monte Carlo Greeks on non-stationary SDEs
-
grabapl
graph-based programming languages, with pluggable type systems and a focus on visible intermediate states
-
draxl-ast
Typed AST and metadata model for Draxl
-
mist-lang
The Mist programming language compiler
-
tyre-ty
Ty compiler CLI
-
harper-comments
The language checker for developers
-
aardvark-core
Runtime for executing sandboxed python bundles inside V8
-
TypeScript-Rust-Compiler
High-performance TypeScript to Rust compiler
-
rowl
Parser for the Dolfin Ontology Language
-
tsz-parser
TypeScript parser and AST types for the tsz compiler
-
midenup
The Miden toolchain manager
-
lex-ast
Canonical AST + content-addressed identity for Lex programs
-
janetrs
High level binding for Janet programming language
-
kn-runtime
Dynamic wrapper around CPU and GPU inference
-
runmat-vm
RunMat virtual machine and bytecode interpreter
-
cargo_pup_lint_impl
Core lint implementations and rustc integration for cargo-pup architectural linting
-
kz80_c
A self-hosting C compiler for Z80 targeting RetroShield hardware
-
xdl-parser
XDL/IDL language parser
-
bend-lang
A high-level, massively parallel programming language
-
analyssa
Target-agnostic SSA IR, analyses, and optimization pipeline
-
t-backend_c
C code generator for the T programming language
-
miden-package-registry
Package registry interfaces and dependency resolution for Miden packages
-
zust-vm-spirv
SPIR-V code generation backend for the Zust scripting language
-
parlex
Core support library for parsers and lexers generated by parlex-gen
-
lisp-rs
Lisp interpreter in Rust
-
hiko-harness
part of the hiko ML-family scripting language
-
ocaml-gen
generating OCaml code
-
prune-lang
Prune is a constraint logic programming language with branching heuristic
-
mutica
programming language
-
cellang
Interpreter for the CEL expression language
-
single-variable-algebra-compiler
A compiler for the minimalistic programming language single-variable-algebra
-
ion-core
Embeddable scripting language with a bytecode VM
-
stator_jse_ffi
Stator JavaScript engine — stable C FFI layer for embedding
-
typr
A typed superset of R - transpiler and type checker
-
scopegraphs
A well-documented port of scopegraphs to Rust
-
tket-json-rs
Serializable definition of TKET circuits and operations
-
zia
Interpreter Library for the Zia Programming Language
-
lamina-ir
Lamina Intermediate Representation — high-level SSA IR for the Lamina compiler
-
oxc_transformer
A collection of JavaScript tools written in Rust
-
quickjspp
QuickJS Javascript engine wrapper using quickjs fork named quickjspp
-
bund
Interpreter and CLI for a Virtual Machine for BUND programming language
-
grapheme-compiler
Compiler pipeline for Grapheme source to MIR artifacts
-
hilang
A small programming language
-
zccache-compiler
Compiler detection and argument parsing for zccache
-
liturgical-calendar
Liturgical calendar engine for the Catholic Novus Ordo — runtime facade
-
duck-diagnostic
Generic diagnostic engine for building rich error reporting into any tool
-
ringkernel-cuda-codegen
CUDA code generation from Rust DSL for RingKernel stencil kernels
-
termaid-mermaid
Mermaid parsing for the Rust termaid terminal renderer
-
turbofuro_worker
Worker executable for Turbofuro
-
fta
Fast TypeScript Analyzer
-
gen-nix
gen — typed Nix AST + pretty-printer + per-crate (crate2nix shape) derivation renderer. Implements theory/NIX-AST.md: every Nix construct the substrate emits is a typed
NixValue… -
cambridge-asm
Run pseudoassembly from Cambridge International syllabus 9618
-
garnish_lang
Single library for re-exporting and documenting all Garnish core libraries
-
pascal
A modern Pascal compiler with build/intepreter/package manager built with Rust
-
regorust
Rust bindings for the rego-cpp Rego compiler and interpreter
-
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.
-
vibe-ast
Multi-language AST parser with language detection
-
proto-blue-codegen
AT Protocol code generator: Lexicon JSON -> Rust source
-
chalk-recursive
Recursive solver for the Chalk project
-
garden-lang
A live programming language
-
mech
programming language for building reactive systems like robots, games, and animations
-
r2u2_cli
R2U2 CLI: A stream-based runtime monitor command-line interface
-
beadie
Hot-function promotion broker for interpreter-to-JIT tiering
-
diffsl
A compiler for a domain-specific language for ordinary differential equations (ODE)
-
nexus-lang
A programming language for generating component network descriptions
-
dlexer
A high-performance, functional parser combinator library for Rust
-
tsbytes
Compile TypeScript directly to native JVM bytecode and executable JARs
-
tripley-rpc-idlc
Compiler and plugin host for Tripley RPC IDL
-
mmi-cli
CLI and compiler for Mastermind, the BF compiler
-
transportations_library
A comprehensive Rust-based library implementing transportation engineering methodologies (e.g. the Highway Capacity Manual (HCM)) with Python bindings.
-
ezno
A fast and correct TypeScript type checker and compiler with additional experiments. For use as a library or through the CLI
-
hugr
Quantinuum's Hierarchical Unified Graph Representation
-
oak-dhall
Dhall language parser with support for functional programming and type system features
-
valua-diagnostics
Diagnostic types and reporting for the valua transpiler
-
tsz-binder
TypeScript name binder for the tsz compiler
-
intent-check
Semantic analyzer and type checker for IntentLang specifications
-
sixtyfive
An interpreter for the Sixtyfive programming language, designed for teaching computer science to moths
-
rlx-umap
Parametric UMAP on RLX — full fit/transform API and k-NN building blocks
-
marigold-grammar
Grammar for the marigold language
-
analisar
A Lua parser for Rust
-
sigil-parser
Parser and native compiler for the Sigil programming language
-
grepdef
Quick search for symbol definitions in various programming languages
-
gleamgen
Gleam generator
-
tsz-common
Common types and utilities for the tsz TypeScript compiler
-
oak-nim
Nim language parser with support for modern Nim syntax and systems programming features
-
create-farm
Create Farm cli tool
-
nextjs_react_compiler_ssa
Rust port of the React Compiler, vendored from facebook/react
-
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…
-
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.
-
surreal-lang
A Rust-inspired language for the BEAM
-
rajac-base
Shared foundational utilities for the rajac compiler workspace
-
typst-macros
Proc-macros for Typst
-
phenotyper-cli
CLI for the Phenotyper compiler
-
provekit_noirc_driver
Driver for the Noir compiler pipeline
-
cargo_info_types
Parse the output of
cargo infointo well-typed Rust structures -
maat_errors
Compiler error types and diagnostic infrastructure for the Maat programming language
-
wasm-pvm-cli
CLI for WASM to PVM recompiler
-
mist-codegen
The Mist programming language Rust code generator
-
ternary-compiler-optimizer
Optimization passes for ternary bytecode
-
type-sitter-cli
CLI for type-sitter (generate typed wrappers for tree-sitter grammars from node-types.json and queries)
-
chapter3_lexical
A lexical analyzer that returns the tokens you wrote!
-
mystsh
Mystical shell parser, formatter, and interpreter with Bash support
-
voce-compiler-wasm
Voce IR WASM compiler — compiles state machines and compute nodes to WebAssembly
-
maat_span
Source span and location types for the Maat compiler
-
intent-implement
AI-powered full implementation generation from IntentLang specifications
-
kz80_calc
VisiCalc-style spreadsheet for Z80 - Retro computing on the RetroShield
-
spade-typeinference
Helper crate for https://spade-lang.org/
-
lambda-expr
evaluating string expressions in hot loops
-
axon-frontend
AXON compiler frontend — lexer, parser, AST, epistemic type system, type checker, IR generator. Zero runtime dependencies. v1.3.0 lowers requires_capabilities into IRAxonEndpoint…
-
remir
MIR library designed to be used easily and be efficient
-
oak-objective-c
Objective-C object-oriented programming language parser with support for Apple platform development and runtime features
-
bop-sys
Standard host integration for the Bop programming language
-
argus-lib
Trait debugger analysis for IDE interactions
-
corvo7
A toy programming language compiler written in Rust
-
spade-diagnostics
Helper crate for https://spade-lang.org/
-
depyler-lambda
AWS Lambda transpilation support for the Depyler Python-to-Rust transpiler
-
graphcal-lsp
Language Server Protocol implementation for Graphcal
-
llvm-pm
Safe Rust wrapper for LLVM new PassManager
-
typst-bundle
Bundle exporter for Typst
-
erg_compiler
Centimetre: the Erg compiler
-
retrolang
systems programming language compiler for Z80 microprocessors
-
amethyst_geode
Turing Machine Programming Language Interpreter
-
aplang
A programming language made to aid students who are taking AP Computer Science Principals
-
ternlang-mcp
MCP server for ternlang — connects any AI agent to balanced ternary decision logic via trit_decide and friends
-
draxl
Agent-native source annotation for semantic program control
-
lexerus
annotated lexer
-
tishlang_ui
Shared JSX lowering and UI runtime (vnode, hooks, host protocol) for Tish
-
aver-lsp
LSP server for the Aver programming language
-
rustpython-vm
RustPython virtual machine
-
alef-backend-magnus
Ruby (Magnus) backend for alef
-
dolang-private-util
Shared utilities for Do language crates
-
piccolo
Stackless Lua VM implemented in pure Rust
-
etcetera-compiler
A Rust-based compiler project
-
alef-snippets
Reusable documentation snippet discovery and validation for Alef
-
axonyx-core
Core parser, lowering, query model, and SQL draft compiler for Axonyx
-
gluon
A static, type inferred programming language for application embedding
-
depyler-hir
High-level Intermediate Representation types for the Depyler transpiler
-
valua-codegen
Lua 5.1 code emitter for the valua transpiler
-
moonjuice-transpiler-luau
Transpile MoonJuice AST nodes to the Luau scripting language
-
mallubind
Native C-ABI bindings for writing libraries for the Malluscript programming language
-
splik
programming language identifier kit
-
oak-crystal
Crystal language parser with support for modern Crystal syntax and Ruby-like features
-
brink-syntax
Syntax types and parser for inkle's ink narrative scripting language
-
c2rust-transpile
C2Rust transpiler implementation
-
cljrs-base64
Base64 library for Clojurust wrapping rust-base64
-
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
-
mag_lang
The Mag Language Runtime
-
t-repl
Shared REPL infrastructure for T and Ty compilers
-
phenotyper
Core compiler library for the Phenotyper structural artifact definition language
-
makepad-live-compiler
Makepad platform live DSL compiler
-
oak-llvm-ir
High-performance incremental LLVM IR parser for the oak ecosystem with flexible configuration, supporting low-level intermediate representation analysis
-
kind2
A pure functional functional language that uses the HVM
-
lite_ml
Lightweight markup language compiler
-
lutra-codegen
Code generation for Lutra
-
cortex-lang
interpreted language for interfacing with Rust code
-
draxl-patch
Structured semantic patch operations over the Draxl model
-
treeedb-javascript
Generate Datalog facts from JavaScript source code
-
equilibrium-ffi
Automatic C FFI generation for C-compiling languages (V, Zig, C++, C#, Rust, D, Nim, Odin) (unstable and in development)
-
rma-parser
Tree-sitter based polyglot parser for Qryon
-
littrs-ruff-python-parser
Vendored ruff_python_parser for littrs (from github.com/astral-sh/ruff)
-
lisette-syntax
Little language inspired by Rust that compiles to Go
-
airl-compile
Cranelift JIT compiler and WASM backend for AIRL IR
-
oxc_napi
A collection of JavaScript tools written in Rust
-
oak-jasmin
Jasmin Java assembler parser with support for Java bytecode assembly and class file generation
-
rajac-ballpit
Experimental sandbox binary for rajac development
-
rew-compiler
CoffeeScript/TypeScript compiler for the Rew runtime
-
zust-parser
Lexer and parser for the Zust scripting language
-
brief-core
Compiler library for the Brief markup language: lexer, parser, AST, HTML/LLM emitters, formatter, and Markdown-to-Brief converter
-
cranelift-interpreter
Interpret Cranelift IR
-
nextjs_react_compiler_reactive_scopes
Rust port of the React Compiler, vendored from facebook/react
-
asg-lang
ASG - A programming language built on Abstract Syntax Graph
-
tsz-scanner
TypeScript scanner/tokenizer for the tsz compiler
-
awa5_rs
An AWA5.0 CLI tool written in Rust (btw)
-
oxur
Lisp dialect that treats Rust as its compilation target and runtime
-
voce-adapter-vercel
Voce IR Vercel deployment adapter — Build Output API v3
-
hclua
-
rusche
A lightweight Scheme interpreter embeddable in Rust applications
-
idpp
ID++ - Bahasa pemrograman berbahasa Indonesia
-
pepl-types
Shared types for the PEPL compiler: AST nodes, Span, errors
-
sixu
Experimental Visual Novel Scripting Language
-
alef-codegen
Shared codegen utilities for the alef polyglot binding generator
-
liteml
一个用 Rust 实现的轻量级标记语言编译器。
-
treeedb-csharp
Generate Datalog facts from C# source code
-
treeedb-c
Generate Datalog facts from C source code
-
typst-cli
The command line interface for Typst
-
bock-ast
Abstract syntax tree definitions for the Bock language
-
maid-lang
Maid Programming Language
-
w16-ir
Промежуточное представление w16, и оптимизации
-
grammatica
representing and transforming formal grammars (Chomsky hierarchy today; extensible toward attribute, probabilistic, and specialized grammars)
-
lamina-codegen
Codegen utilities for Lamina (register allocation, ABI, frame management)
-
temporaries
Make temporary values useable in a fairly normal style through macros. This nicely wraps the hacks that work around temporaries’ earlier limitations.
-
typescript
compiler and runtime
-
resw
writing RESSA AST parts to a file
-
emlex
A zero-cost S-expression mathematical DSL engine for Rust. Provides compile-time evaluation, AST preservation, optimization, and reverse DSL reconstruction.
-
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.
-
brk_rolldown_ecmascript
ECMAScript AST and parsing utilities for Rolldown
-
sync-ls
Synchronized language service inspired by async-lsp, primarily for tinymist
-
graphcal-fmt
Type-safe, unit-aware, Git-friendly reactive programming language for engineering calculations
-
libwild
that provides a fast Linux linker
-
thinkinglanguage-types
ThinkingLanguage — Type system and type checker
-
w16-core
Ядро W16
-
leo-retriever
A retriever for the Leo programming language
-
lutra-interpreter
Bytecode interpreter for Lutra programs
-
uac
universal assembly compiler
-
fasb
faceted answer set browser
-
bock-lexer
Tokenizer for the Bock language
-
bock-codegen
Multi-target code generation for Bock — JS, TS, Python, Rust, Go
-
aver-rt
Shared Rust runtime pieces for Aver-generated programs
-
sema-core
Core types and environment for the Sema programming language
-
lift-sim
Static analysis engine — shape propagation, FLOP counting, memory analysis, noise simulation
-
leo-std
Embedded Leo standard library source
-
ilm
A fun programming language with Islamic terminology
-
hypothalamus
An optimizing Brainfuck AOT compiler with an LLVM IR backend
-
jasm-assembler
Modern assembler for JVM instruction set - strongly typed, object-oriented, zero-dependency core
-
oxc_compat
A collection of JavaScript tools written in Rust
-
just-engine
A ground-up ES6 JavaScript engine with tree-walking interpreter, bytecode VMs, and Cranelift JIT compiler
-
check-updates-core
Shared core library for check-updates tools
-
tspc
TypeSpec compiler CLI — convert .tsp files to JSON, YAML, OpenAPI and more
-
sema-vm
Bytecode compiler and virtual machine for the Sema programming language
-
spade-lang
The Spade compiler
-
ast-demangle
Parses mangled names and produces structured results
-
qbe
QBE IR for Rust
-
mist-api
The Mist programming language module system
-
lexit
A Lexical Analysis tool for defining a language and lexing it into tokens
-
pepl-compiler
PEPL compiler: orchestrates the full compilation pipeline
-
omg_runtime
The OMG language runtime and virtual machine, providing bytecode execution, REPL, and built-in functions
-
strontium
A register-based bytecode machine for statically and dynamically typed programming languages
-
flux-ast
Universal Constraint AST — single source of truth for constraint semantics across all representations
-
maat_stdlib
Standard library sources for the Maat programming language
-
fift-cli
A CLI for the Fift esoteric language interpreter
-
oak-koka
Koka frontend for Oak
-
primate
A small DSL for cross-language constants. Write once, generate typed Rust, TypeScript, and Python.
-
midenc-frontend-wasm-metadata
Shared frontend metadata codec for the Miden Wasm frontend
-
oak-php
PHP server-side scripting language parser with support for web development and modern PHP features
-
pepl-parser
PEPL parser: token stream to AST
-
vyre
GPU compute intermediate representation with a standard operation library
-
voce-compiler-ios
Voce IR iOS compiler — compiles IR to SwiftUI code with VoiceOver accessibility
-
mist-parser
The Mist programming language parser
-
cambridge-asm-cli
Run pseudoassembly from Cambridge International syllabus 9618
-
swamp-semantic
semantic types for swamp
-
lep
Mini language for interactive consoles, featuring small code footprint
-
astmap-languages
Language parsers and resolvers for astmap (tree-sitter based)
-
rnsc
RNS assembler/compiler CLI for the Lagertha VM project
-
misty-parser
Parser code required by the Misty Compiler
-
muga
A quiet programming language
-
crisp
A small, expressive Lisp-inspired programming language
-
haloumi-ir-gen
IR generation step of the haloumi lowering pipeline
-
refrain-core
Differential Refrain Engine core: DSL parser and AST
-
makepad-live-tokenizer
Makepad platform live DSL tokenizer
-
symjit-bridge
a bridge bwtween Symjit compiler and Symbolica CAS
-
sqry-lang-ruby
Ruby language plugin for sqry
-
llts
TypeScript to native compiler via LLVM
-
qvcm
Register-based bytecode VM with quantum computing functionality
-
oak-rst
High-performance incremental reStructuredText parser for the oak ecosystem
-
lift-hybrid
Fusion dialect — classical-quantum data encoding, joint gradient computation
-
stak-device
Devices for Stak Scheme
-
motto
Compiler-as-a-Service: Turn Rust schema.rs into multi-platform SDK toolkits
-
hugr-persistent
Persistent IR structure for Quantinuum's HUGR
-
ascent-interpreter
Interpreter and JIT for Ascent Datalog programs
-
tremor-script
Tremor Script Interpreter
-
changepacks-csharp
C# (.NET) project support for changepacks (NuGet)
-
miden-package-registry-local
Filesystem-backed local package registry for Miden packages
-
lift-cli
LIFT CLI: Command-line interface — verify, analyse, print, compile, simulate, predict
-
duck-diag
Generic diagnostic engine for building rich error reporting into any tool
-
hmacro
macro preprocessor
-
voce-compiler-android
Voce IR Android compiler — compiles IR to Jetpack Compose with TalkBack accessibility
-
maat_lexer
DFA-based lexer for the Maat programming language
-
nightjar-lang
A declarative, prefix-notation DSL for formal verification of structured data
-
b3
port of B3 WebKit codegen backend
-
flt
a 'lite' functional language
-
treeedb-souffle
Generate Datalog facts from Soufflé source code
-
tl-lsp
Language Server Protocol implementation for ThinkingLanguage
-
phon-jit
phon's optional copy-and-patch JIT: lowers the IR to machine code via rustc/LLVM stencils
-
fusabi-frontend
Frontend (parser, compiler) for Fusabi language
-
lau-agent-runtime
Self-compiling agent runtime — agents build their own interpreters, compilers, and runtimes
-
jzero-codegen
TAC and bytecode code generation for the Jzero compiler
-
forgellm-frontend
Model parsing (GGUF, SafeTensors) and IR construction for ForgeLLM
-
oak-vbnet
VB.NET parser for the Oaks framework
-
py5
A minimalist Python interpreter written in Rust
-
xpile
Polyglot transpile workbench (Python/C/C++/Rust/Ruchy/Lean ↔ Rust/Ruchy/PTX/WGSL/SPIR-V) with provable contracts at every layer
-
kz80_prolog
Prolog compiler for Z80 - Logic programming on the RetroShield
-
bappy-script
Gankra's toy compiler
-
mago-codex
PHP type system representation, comparison logic, and codebase metadata for static analysis
-
oak-ocaml
OCaml functional programming language parser with support for modern OCaml features and type system
-
reqlang-expr
A tiny (bytecode compiled, stack VM interpreted) expression language for reqlang's templating engine
-
koto_bytecode
The bytecode compiler used by the Koto programming language
-
koto_parser
The parser used by the Koto programming language
-
leap-lang
Leap language parser
-
wesley-emit-typescript
AST-based TypeScript emitter for Wesley IR
-
mlua-crc16
A Rust-native implementation of LuaRocks youlu/luacrc16 for mlua
-
edlc_lsp
EDLc Language Sever Protocol implementation
-
oak-scala
High-performance incremental Scala parser for the oak ecosystem with flexible configuration, supporting functional programming and JVM ecosystem integration
-
bock-core
Core stdlib registry and runtime primitives for the Bock language
-
lua2hcb_compiler
A compiler for Lua-like scripts to HCB
-
typst-batch
Typst helper library for batch processing — friendly API, shared resources, virtual files, customizable diagnostics
-
umjunsik
Language compiler targeting Lamina IR
-
vize_atelier_sfc
Atelier SFC - The Single File Component workshop for Vize
-
oak-r
R statistical programming language parser with support for data analysis, statistical computing, and graphics
-
naga-rust-embed
Translates WGSL shader code to Rust embedded in your Rust code
-
lift-import
Importers — PyTorch FX, ONNX, Qiskit, OpenQASM 3
-
oxide_lisp
lisp interpreter engine in Rust
-
beadie-backend
JitBackend trait, BackendAdapter, BoundBead, and TieredAdapter
-
ruby
Pure Rust implementation of Ruby runtime environment
-
svod-codegen
Backend code generation for the Svod ML compiler
-
wmlua
-
tl-ir
Intermediate Representation for ThinkingLanguage table pipe optimization
-
strykelang
A highly parallel Perl 5 interpreter written in Rust
-
gluon_base
Basic type definitions and functions for the gluon programming language
-
tsz-emitter
TypeScript-to-JavaScript emitter and transforms for the tsz compiler
-
maat_trace
Trace-generating virtual machine for the Maat programming language
-
cilly
creating .NET and optimizing .NET assemblies
-
cargo-typify
cargo command to generate Rust code from a JSON Schema
-
coda-runtime
the runtime for coda, an experimental scripting language
-
oak-racket
Hand-written Racket frontend
-
lamina-platform
Platform and target detection for Lamina compiler
-
uiua_parser
Uiua parser implementation
-
chord-progression-parser
a converter from chord progression strings to AST
-
steel-doc
Document generation for steel
-
pen-ffi
FFI library for Pen programming language
-
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.
-
steel-rc
Biased reference counting implementation for steel
-
espy
a functional, embeddable, extendable scripting language
-
scala
A experimental Scala interpreter written in Rust: lexer, parser, type inference, and tree-walking evaluation with a REPL
-
mec
mruby/edge compiler cli endpoint
-
stak-util
Stak Scheme utilities
-
lisette-diagnostics
Little language inspired by Rust that compiles to Go
-
cuda-forth
Minimal Forth agent language
-
mblf
The MBLF-To-BF compiler written in Rust with Pest. MBLF is a programming language on top of the esoteric programming language Brainfuck
-
modu
A fast and simple turning-complete interpreted language
-
bock-source
Source file management and FileId mapping for the Bock language compiler
-
treeedb-java
Generate Datalog facts from Java source code
-
lamina-mir
MIR (Machine Intermediate Representation) type definitions for Lamina
-
dolang-compile
Parser, resolver, and bytecode compiler for the Do language
-
bop-vm
Bytecode compiler and stack VM for the Bop programming language
-
squid
A RISC-V emulator with AOT compilation for fuzzing
-
tsz-checker
TypeScript type checker for the tsz compiler
-
refrain-egraph
Differential Refrain Engine: egglog rewrite engine bindings
-
voce-adapter-static
Voce IR static deployment adapter — plain dist/ folder output
-
oxc_jsdoc
A collection of JavaScript tools written in Rust
-
treeedbgen-souffle-souffle
Generate Soufflé types and relations from the Soufflé tree-sitter grammar
-
swc_fast_ts_strip
Super-fast TypeScript stripper based on SWC
-
type-sitter-gen
generate typed wrappers for tree-sitter grammars from node-types.json and queries
-
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… -
haloumi-ir
Intermediate representation of the haloumi framework
-
arithma
An easy to use, domain-specific programming language for numeric mathematics
-
gluon_c-api
C-api for gluon, a static, type inferred programming language for application embedding
-
rustpython-ast
AST definitions for RustPython
-
resrap-rs
A rule based code generator
-
mathcompile
High-performance symbolic mathematics with final tagless design, egglog optimization, and Rust hot-loading compilation
-
obscura-core
Core obfuscation engine: AST transforms, options, pipeline. Rust port of javascript-obfuscator.
-
wscript-cli
CLI runner for Wscript
-
lisette-emit
Little language inspired by Rust that compiles to Go
-
rspression
A high-performance, lightweight expression calculation engine
-
rvsdg
Type-safe standalone implementation of the RVSDG IR with automatic Phi transformation
-
bock-vocab
Self-describing language vocabulary emitter for Bock — keywords, errors, prelude, stdlib, annotations
-
fugue-sleighc
Wrapper around Ghidra's SLEIGH specification compiler
-
pydis
Python 2.7 bytecode disassembler
-
ergotree-ir
ErgoTree IR, serialization
-
vyre-emit-ptx
PTX text emitter for vyre KernelDescriptor. Produces NVRTC-compatible CUDA assembly.
-
koto_runtime
The runtime used by the Koto programming language
-
egglog-core-relations
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.
-
whitespacers
A whitespace JIT-compiler, for when your whitespace just isn't executing fast enough
-
mago-traverser
traverse AST nodes
-
pflow-dsl
S-expression DSL for defining token model schemas
-
bock-fmt
Source code formatter for the Bock language
-
llvm-in-rust-target-x86
x86-64 target backend for LLVM-in-Rust code generation
-
ling-codegen
Code generation backends for Ling (bytecode, WASM, native)
-
swc_ecma_react_compiler
SWC helpers for the React Compiler
-
onion-vm
Virtual machine runtime for the Onion programming language with async execution and garbage collection
-
netidx-bscript
An incremental scripting language for netidx
-
llvm-in-rust-target-arm
AArch64 target backend for LLVM-in-Rust code generation
-
rocalang
A contractual language for the AI era
-
lift-predict
Performance prediction engine — analytical roofline model, budget enforcement
-
maat_air
CPU constraint system (AIR) for the Maat programming language
-
stak-macro-util
Macro utilities for Stak Scheme
-
llvm-in-rust-analysis
Control-flow, call-graph, dominance, loop, and use-def analyses for LLVM-in-Rust IR
-
tket2-hseries
TKET2 tool for preparing and validating
Hugrs for compilation targeting Quantinuum H-series quantum computers -
unseemly
A typed macro language
-
php-printer
Pretty printer for PHP AST — converts parsed AST back to PHP source code
-
uv-types
internal component crate of uv
-
airl-ir
Core IR data structures for AIRL (AI-native Intermediate Representation Language)
-
jjik
LR(1) parser generator
-
wasc
A C-like language compiler for WebAssembly with first-class support for references and tables
-
forge-lang
Forge — Internet-native programming language with natural syntax, bytecode VM, and built-in HTTP/database/crypto
-
haloumi-picus
Haloumi backend to the Picus Constraint Language
-
orco
A compiler backend interface
-
refrain-adapters
Differential Refrain Engine: output adapters (audio, visual, code, text)
-
ana-lang
A small interpreted language
-
vpratt
absolute zenith of pratt parsing
-
telltale-machine
Protocol machine for choreographic session type protocols
-
xasm-rs
generating linux 32/64 bit assembly easily
-
dolfin-diagnostic
Unified diagnostic types for the Dolfin toolchain
-
libquil-sys
High-level bindings to libquil
-
tsz-lsp
Language Server Protocol implementation for the tsz compiler
-
hvm1
A massively parallel functional runtime
-
tabulon
A high-performance, JIT-compiled expression evaluation engine using Cranelift
-
llvm-in-rust-ir-parser
Lexer and parser for LLVM textual IR into LLVM-in-Rust data structures
-
lisette-semantics
Little language inspired by Rust that compiles to Go
-
midenc-dialect-wasm
Miden IR Wasm Dialect
-
svod-runtime
Kernel execution runtime for the Svod ML compiler
-
bhc-ast
Abstract syntax tree definitions for BHC
-
spec-checker
Property-based and runtime-gate checker for Lex specs
-
nl_opt
Verilog compiler driver for running safety-net passes
-
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.
-
turing-lib
Turing library for Rust
-
tsz-lowering
AST-to-type lowering bridge for tsz
-
uv-installer
internal component crate of uv
-
phpdoc-parser
Structural PHPDoc parser. Parses doc-comment blocks into a tag/prose AST with accurate spans; tag bodies exposed as raw text.
-
lisette-format
Little language inspired by Rust that compiles to Go
-
melody_compiler
The Melody language compiler
-
ccarp
(trans)Compile C And Rust Partially
-
cargo-slicer
Speed up Rust release builds by skipping codegen for unreachable functions and processing of other skippable items
-
vexil-lang
Compiler library for the Vexil schema definition language — lexer, parser, IR, and type checker
-
edlc_core
Core library for the EDL compiler
-
oak-von
Valkyrie language parser with support for modern Valkyrie syntax and features
-
lex
aids in parsing programming languages
-
depinfo
parser for Rust
-
erg_common
A common components library of Erg
-
morok-dtype
Type system for the Morok ML compiler
-
pliron-llvm
LLVM dialect for pliron
-
static-reflect
Static type information, giving a form of compile-time reflection
-
morok-runtime
Kernel execution runtime for the Morok ML compiler
-
wesl-cli
CLI for the WESL compiler
-
tapir-bf
Tapir is a moderately useful Brainfuck interpreter
-
bock-interp
Tree-walking interpreter for the Bock language, used by
bock runand tests -
rsjsonnet-lang
A Jsonnet evaluation library
-
cgrammar
A comprehensive C language grammar parser library written in Rust, implementing the C23 standard (ISO/IEC 9899:2023)
-
csw-cli
Command-line interface for the Categorical Semantics Workbench
-
oak-mojo
Mojo frontend for Oak
-
cfi-types
CFI types for cross-language LLVM CFI support
-
cmtc
compiler providing cmtir-based passes to generate backends including FIRRTL, SystemVerilog and simulators
-
swc_ecma_transforms_optimization
rust port of babel and closure compiler
-
specl-syntax
Lexer, parser, and AST for the Specl specification language
-
oak-voml
Valkyrie language parser with support for modern Valkyrie syntax and features
-
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…
-
brink-lsp
Language server for inkle's ink narrative scripting language
-
haskelujah-naming
Name resolution, interfaces, and symbol environments for the Haskelujah compiler
-
voce-adapter-core
Voce IR deployment adapter trait and shared types
-
rust-guile
Scheme runtime in your Rust program
-
umpl
meme language that is a mix of c like languages and lisp like languages
-
graphcal-io
Filesystem implementations for the Graphcal compiler
-
gluon_completion
Auto-completion for the gluon programming language
-
horkos
Cloud infrastructure language where insecure code won't compile
-
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.
-
light_ranged_integers
Ranged integers for stable Rust compiler, zero-dependencies and no unsafe code
-
wrecc
A x86_64 C99 compiler written from scratch
-
backyard-nodes
Nodes representing PHP code AST
-
dalbit
A Luau-to-Lua transpiler
-
espr
EXPRESS Language compiler
-
lu
embedding Luau
-
nessa-language
An extensible programming language with a strong type system
-
crane-win64
A high-performance direct-to-binary compiler backend with built-in IR parser
-
voce-adapter-netlify
Voce IR Netlify deployment adapter
-
bop-cli
CLI and REPL for the Bop programming language
-
provekit_noir_artifact_cli
Commands working on noir build artifacts
-
magc
The Mag Language Compiler
-
typst-svg
SVG exporter for Typst
-
vyre-foundation
Foundation layer: IR, type system, memory model, wire format. Zero application semantics. Part of the vyre GPU compiler.
-
swamp-parser
Parses Swamp programming language source code into an Abstract Syntax Tree (AST) defined in the
swamp-astcrate, using the pest parsing library -
tl-interpreter
Tree-walking interpreter for ThinkingLanguage (Phase 0)
-
typescript-types
Type definitions for TypeScript compiler
-
ironmind
A Brainf*ck interpreter and code execution visualizer built in Rust
-
rajac-lexer
Java lexer for the rajac compiler
-
sandkiste
Language independent scripting language sandbox API
-
seacc
A sea-of-nodes C compiler, written in Rust
-
brink-codegen-inkb
Bytecode codegen backend: LIR → StoryData (inkb format)
-
otter-runtime
JavaScriptCore runtime for otter - TypeScript/JavaScript execution engine
-
flux-isa
FLUX Instruction Set Architecture — stack-based constraint compilation VM with bytecode encoding
-
haloumi-synthesis
Synthesis step of the haloumi lowering pipeline
-
lang-interpreter
reimplementation of the Standard Lang interpreter
-
parlex-gen
Lexer generator ALEX and parser generator ASLR
-
voce-schema
Voce IR schema definitions and generated FlatBuffers bindings
-
swiftsc-cli
Command-line interface for SwiftSC-Lang compiler
-
tsz-solver
TypeScript type solver for the tsz compiler
-
provekit_noirc_frontend
Frontend for the Noir compiler
-
dolang-bytecode
Bytecode format and verification for the Do language
-
rever
Interpreter and REPL for the Rever language
-
jrsonnet-evaluator
jsonnet interpreter
-
penne
pasta-oriented programming language that favors the goto-statement for flow control
-
draxl-parser
Language-dispatch facade for Draxl parsing
-
ad-astra
Embeddable scripting language platform Ad Astra. Main Crate.
-
bcts
Incremental compiler infrastructure using Salsa
-
parlex-calc
Parlex example: simple calculator
-
stacky
Programming Language
-
depyler-mcp
Model Context Protocol integration for Depyler
-
fusabi
A potent, functional scripting layer for Rust infrastructure
-
rgsm
An assembler for the Gheith ISA written in Rust
-
haloumi-lowering
Core traits for enabling types to integrate with the codegen module
-
draxl-validate
Structural validation for Draxl source files
-
parsuna
recoverable, pull-based parsers with precise errors
-
kz80_db
dBASE II clone for Z80 - Retro database on the RetroShield
-
provekit_noirc_arena
Arena allocator for Noir compiler data structures
-
cppshift
CPP parser and transpiler
-
tinymist-project
Project model of typst for tinymist
-
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
-
runmat-turbine
Cranelift-based JIT compiler for RunMat - the optimizing tier of our V8-inspired execution model
-
swipl
A high-level library for building SWI-Prolog extensions and embedding SWI-Prolog in rust applications
-
amble_script
Authoring-focused DSL, parser, and compiler that produces Amble engine WorldDef data
-
voce-adapter-cloudflare
Voce IR Cloudflare Pages deployment adapter
-
bock-build
Build pipeline for Bock projects, coordinating parse, check, codegen, and target compilation
-
mech-compare
Comparison library for the Mech language
-
oxc_react_compiler
oxc integration for the Rust port of React Compiler
-
rustc_codegen_spirv-types
SPIR-V backend types shared between rustc_codegen_spirv and spirv-builder
-
hannibal-lexer
DFA based Lexer written in Rust
-
sleigh-compiler
Rust bindings for the Ghidra SLEIGH compiler. Used to compile processor .slaspec files into .sla files
-
peepmatic
DSL and compiler for generating peephole optimizers
-
rustleaf
programming language interpreter written in Rust
-
tupa-lint
Linter for TupaLang source code
-
firmion-diags
Error message reporting used by the firmion compiler
-
archscript
programming language — Python-like syntax, Haskell-inspired features, Arch Linux integration
-
jinko
safe, small and fast programming language with Rust interoperability
-
verbena
Scripting language
-
recc
A C compiler with graphs
-
suffete
A standalone PHP type system: representation, comparison, and type checking primitives for static analysis tools
-
gluon_format
Code formatting for the gluon programming language
-
tatara-lisp-eval
Runtime evaluator for tatara-lisp — embeddable Scheme-ish eval scoped to orchestration (job queues, rules, REPL). See docs/eval-design.md.
-
backyard-parser
Parse PHP code to AST node
-
ghci
Manage and communicate with ghci (Haskell's GHC interpreter)
-
rusty-javac
A Java compiler written in Rust
-
monkey-compiler
a compiler for monkeylang
-
w16-lib
Библиотека для использования W16
-
phoenix-lang
fast programming language
-
rust_mir2_wrapper
RUSTC_WORKSPACE_WRAPPER binary for rust_mir2 MIR extraction
-
bock-ai
AI provider interface for Bock's AI-native code generation pipeline (Generate, Repair, Optimize, Select)
-
qir-qis
QIR to Quantinuum QIS (Quantum Instruction Set) compiler
-
espy-tail
espy's bytecode compiler
-
fastc-lsp
Language Server Protocol implementation for FastC
-
intent-gen
Natural language to IntentLang spec generation via LLM (Layer 0)
-
eureka-optimizer
A short description
-
tjs2dec
A krkr2 and krkrz tjs2 bytecode decompiler written in Rust
-
koto_memory
Memory management utilities used by the Koto programming language
-
mathic
A compiler with builtin support of symbolic operations, built with LLVM/MLIR
-
pfcl-repl
PFCL REPL and file runner — pure functional language with content-addressed catalog
-
paramodel-plan
Paramodel test-plan layer: TestPlan, Axis, ExecutionPolicies, OptimizationStrategy, TrialOrdering, plan-level bindings
-
xee-interpreter
Interpreter for XPath and XSLT
-
steel-interpreter
Steel repl and command line interface
-
tinymist-world
Typst's World implementation for tinymist
-
voile
dependently-typed row-polymorphic programming language
-
rns-lang
RNS language parser, compiler, and assembler library for the Lagertha VM project
-
devsper-compiler
Distributed AI Swarm Runtime
-
treeedb-cpp
Generate Datalog facts from C++ source code
-
treeedb-go
Generate Datalog facts from Go source code
-
axonml-jit
JIT compilation for Axonml tensor operations
-
moore-svlog-syntax
The SystemVerilog parser implementation of the moore compiler framework
-
moore
A compiler for hardware description languages
-
rajac-types
Type system data structures for the rajac compiler
-
aikup
Manage multiple versions of aiken
-
gluon_repl
REPL for gluon. A static, type inferred programming language for application embedding
-
spade-hir-lowering
Helper crate for https://spade-lang.org/
-
verter_span
Typed span primitives for Verter — compile-time safety for position encoding
-
destack
Rust client for Destack
-
flowistry
Modular information flow analysis
-
obeli-sk-boa-engine
Boa is a Javascript lexer, parser and compiler written in Rust. Currently, it has support for some of the language.
-
moore-vhdl-syntax
The VHDL parser implementation of the moore compiler framework
-
runmat-snapshot
High-performance snapshot creator for preloading RunMat standard library
-
treeedbgen-souffle-rust
Generate Soufflé types and relations from the Rust tree-sitter grammar
-
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.
-
ts-pack-cli
CLI tool for tree-sitter language pack - manage parser downloads and run code intelligence
-
tr-lang
A programming language made to bring syntax closer to Turkish
-
souper-ir
manipulating Souper IR
-
quantalang
compiler — an effects-oriented systems language with multi-backend codegen (C, HLSL, GLSL, SPIR-V, LLVM IR, WebAssembly, x86-64, ARM64)
-
udonsharp-compiler
WASM to UdonSharp compilation pipeline
-
synoema-types
Synoema — programming language optimized for LLM code generation
-
yagbas
programming language that builds programs for the Game Boy
-
phoron_asm
A Jasmin-compatible Assembler for the JVM
-
qalam
Interpreter for the Qalam programming language. Qalam is a dead-simple, Urdu inspired, interpreted programming langauge.
-
c2rust-ast-builder
Rust AST builder support crate for the C2Rust project
-
treeedbgen-souffle-c
Generate Soufflé types and relations from the C tree-sitter grammar
-
spl
Stack Pogramming Language: A simple, concise scripting language
-
sema-eval
Trampoline-based evaluator and module system for the Sema programming language
-
grove-ast
Abstract syntax tree types and balanced ternary primitives for the Grove compiler ecosystem
-
general-parser
Configurable parser for S-expressions with configurable extensions for mathematical notation
-
pycrust
A sandboxed python interpreter (and soon to be compiler)
-
syntax-core
Fast, multi-strategy parsing and transformation kit for Rust
-
sql-ast
A lean sql AST and parser
-
molt-forked
Embeddable TCL interpreter for Rust applications (personal forked)
-
zust-vm-metal
Metal shader source generation backend for the Zust scripting language
-
jzero-semantic
Semantic analysis and type checking for the Jzero compiler
-
kz80_lua
A Tiny Lua interpreter and compiler for RetroShield Z80
-
mogi_sleigh_parser
Parser for Sleigh specifications
-
rajac-ast
Abstract syntax tree definitions for the rajac Java compiler
-
odra-casper-wasm-env
Odra Casper WASM backend
-
fastc
A safe C-like language that compiles to C11
-
icss-lang
Indented CSS parser and compiler
-
lift-core
SSA IR foundation — types, values, operations, blocks, regions, verifier
-
itsy
Strongly typed scripting language with a rusty syntax and nice Rust integration
-
b2c2-casl2
b2c2におけるCASL2の雑なパーサー?
-
ellie_engine
Why ellie? Ellie is a type-safe programing language that runs on embedded and sandboxed environments
-
jzero-ast
Syntax tree data structures for the Jzero compiler
-
rajac-symbols
Symbol tables and semantic symbol data for rajac
-
lisette-stdlib
Little language inspired by Rust that compiles to Go
-
rajac-diagnostics
Diagnostic reporting infrastructure for rajac
-
jzero-symtab
Symbol table types for the Jzero compiler
-
aarchmrs-instructions
AARCHMRS-generated ARM instructions functions
-
zhc_utils
Shared utilities for the ZHC compiler
-
monkey-interpreter
an interpreter for monkeylang
-
edlc_analysis
Code analysis utils EDL compiler
-
maat_runtime
Runtime value system for the Maat programming language
-
XLang-Rust
An experimental cross-platform dynamic strong-typed programming language written in Rust
-
tvm
Rust frontend support for TVM
-
vyre-emit-naga
Naga IR emitter for vyre KernelDescriptor. Produces wgpu-compatible compute shaders.
-
haloumi-backend
Generic backend API of the haloumi framework
-
pycc-rs
Pin1Yin1 compiler rust implementation
-
kaledis_dalbit
A fork of a Luau-to-Lua transpiler based on darklua to use for kaledis
-
backyard-generator
Convert AST node back to PHP code
-
maat_prover
Zero knowledge STARK prover and verifier for the Maat programming language
-
treeedb-swift
Generate Datalog facts from Swift source code
-
gluon_parser
The parser for the gluon programming language
-
treeedb-php
Generate Datalog facts from PHP source code
-
synoema-parser
Synoema — programming language optimized for LLM code generation
-
treeedb-rust
Generate Datalog facts from Rust source code
-
rajac-token
Token definitions for the rajac Java frontend
-
badder_lang
A specialized programming language built for programming puzzle game Robo Instructus
-
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.
-
tidepool-codegen
Cranelift-based JIT compiler for Tidepool Core
-
gluon_check
The typechecker for the gluon programming language
-
snli
An interpreter for the Syntax Null Language Esolang
-
llvm-lib
LLVM library with safe and flexibility in mind, without over complexity based on LLVM-C API
-
satteri-mdxjs
Compile MDX to JavaScript in Rust
-
stailwc
An experimental transpiler to bring tailwind macros to SWC rocket
-
lovely
A delightful low-level systems programming language
-
passerine
A small extensible functional scripting language designed for concise expression with little code
-
diatom
programming language
-
sphinx-lang
An intepreter for a dynamic language implemented in Rust
-
tsn
TypeScript to native executable compiler - Stable Release
-
garnish_lang_runtime
Runtime and execution library for Garnish Lang
-
monkey-object
a object system for monkey lang
-
somni-expr
An expression evaluation library
-
sema-reader
Lexer and s-expression parser for the Sema programming language
-
hcb2lua_decompiler
A decompiler for HCB scripts to Lua
-
tinymist-query
Language queries for tinymist
-
asa
Advanced Subleq Assembler. Assembles 'sublang' to subleq
-
typescript-ir
Intermediate representation for TypeScript compiler
-
treeedb-python
Generate Datalog facts from Python source code
-
brik64-bir
BRIK-64 BIR bytecode runtime — embed the BIR interpreter in any Rust project
-
fomoscript
Toy scripting language
-
brvm
Brainrot language compiler and virtual machine
-
gust-lang
The Gust programming language compiler — parse .gu state machine files and emit Rust, Go, WASM, no_std, or C FFI code
-
jzero-lexer
Lexer for the Jzero language (a subset of Java)
-
ankha
scripting toolset
-
smc-assembler
assembler for a variety of MineCraft architectures
-
rajac-parser
Java parser for the rajac compiler
-
mech-io
Input/output library for the Mech language
-
jzero-parser
LR(1) parser for the Jzero language
-
rosetta-stone-ir
Rosetta Intermediate Representation for cross-language transpilation
-
langbox
framework to build compilers and interpreters
-
p2sh
Programming language interpreter
-
rosetta-stone-core
Core types and traits for the Rosetta transpiler
-
shader-slang
Rust bindings for the Slang shader language compiler
-
flow_analyzer
Semantic analyzer for the Flow programming language
-
lex-syntax
Tokenizer + parser for the Lex programming language
-
ringkernel-wgpu-codegen
WGSL code generation from Rust DSL for RingKernel
-
mosaic-lang
A compiler for Mosaic
-
provekit_noirc_evaluator
Evaluator for the Noir compiler SSA pipeline
-
farmfe_utils
farm utils
-
edlc_codegen_cranelift
Cranelift codegen backend for the EDL compiler
-
sora-config-format
powerful configuration table compiler for games and data-heavy tools
-
tan
language
-
wick-core
Core expression language for wick
-
synoema-core
Synoema — programming language optimized for LLM code generation
-
guryvsr
esoteric programming language gur yvsr
-
synoema-eval
Synoema — programming language optimized for LLM code generation
-
parsit
very simple lib, the parsing combinators, recursive descendent that uses logos as lexer
-
bfy
Brainfu*k interpreter and REPL written in Rust
-
miden-field-repr
Serialization/deserialization for felt representation
-
moore-vhdl
The VHDL implementation of the moore compiler framework
-
nash-ast
Canonical AST for the nash programming language
-
tinymist-l10n
Localization support for tinymist and typst
-
rlibc-extended
A minimal implementation of assumed symbols of libc
-
synth-frontend
WASM/WAT parser and module decoder frontend for the Synth compiler
-
kombucha
A minimal and malleable programming language for symbiotic end-user programming
-
tel
Turbofuro Expression Language
-
lolli-cli
Command-line interface for the Lolli linear logic workbench
-
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.
-
panproto-jit
LLVM JIT compilation of panproto expressions for accelerated data migration
-
tinymist-render
Rendering features for tinymist
-
ringkernel-ir
Intermediate Representation for RingKernel GPU code generation
-
graphcal-compiler
Type-safe, unit-aware, Git-friendly reactive programming language for engineering calculations
-
irvm-lower
The lowering library for IRVM to go to LLVM IR
-
sorth
Forth inspired interpreted programming language
-
c64-assembler
Commodore 64 assembler, outputs directly to .PRG or Dasm source code
-
valua-ast
Lua 5.5 AST node definitions shared across the valua pipeline (Lua 5.4 is a supported subset)
-
rat-in-a-tube
Rat In a Tube, Halo: Combat Evolved HSC Script Compiler
-
astray
Easily define AST using only Rust structures
-
tl-gpu
GPU tensor compute for ThinkingLanguage via wgpu
-
draxl-printer
Language-dispatch facade for Draxl rendering
-
maat_codegen
Bytecode code generation for the Maat programming language
-
jzero-vm
Bytecode interpreter and VM for the Jzero language
-
vast
Verilog AST library
-
blockly-rust-compiler
Rust compiler integration library for visual programming with Blockly - validate and check generated code
-
tinymist-analysis
Typst Static Analyzers for Tinymist
-
michaelb/sniprun
A neovim plugin to run lines/blocs of code (independently of the rest of the file), supporting multiples languages
-
dolang-private-test
Test support utilities for Do language crates
-
spydecy-c
C AST parser for Spydecy transpiler with CPython API recognition
-
prima-academy
Academic course classification primitives for Prima
-
vyder
Create custom libraries for vyder
-
kn-cuda-sys
A wrapper around the CUDA APIs
-
haloumi
Entrypoint crate for the Haloumi framework
-
bock-parser
Parser for the Bock language, producing AST nodes from token streams
-
virtual-rust
A virtual machine that interprets and runs Rust source code directly without compilation
-
swamp-vm-disasm
disassembler for the opcodes in the swamp vm
-
flow_ast
Abstract Syntax Tree definitions for the Flow programming language
-
falsec
An interpreter and compiler for the esotheric programming language FALSE
-
maat_types
Hindley-Milner type inference engine for the Maat programming language
-
logics-rs
Logics is a user-friendly formula language with a subset of Python's expression syntax
-
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.
-
px-llvm-codegen-utils-version-macros
Version macros for LLVM codegen utilities
-
sema-lang
Sema — a Lisp dialect with first-class LLM primitives
-
synoema-lexer
Synoema — programming language optimized for LLM code generation
-
lift-opt
Pass manager and optimisation passes — constant folding, DCE, tensor fusion, gate cancellation
-
firmion-const-eval
Constant evaluation used by the firmion compiler
-
oak-lua
High-performance incremental Lua parser for the oak ecosystem with flexible configuration, supporting lightweight scripting and embedded development
-
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
-
clover
A scripting language
-
viper-py
A fast Python interpreter written in Rust
-
kdl-script
execute kdl documents!
-
ezno-checker
A fast and correct TypeScript type checker with additional experiments
-
spydecy-hir
High-level Intermediate Representation (HIR) for Spydecy transpiler
-
vyre-driver
Driver layer: registry, runtime, pipeline, routing, diagnostics. Substrate-agnostic backend machinery. Part of the vyre GPU compiler.
-
kn-graph
A neural network inference graph intermediate representation, with surrounding utilities
-
tl-llvm
LLVM backend for ThinkingLanguage (Phase 30)
-
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
-
santiago
A lexing and parsing toolkit for Rust
-
myriad-rs
VM runtime for Polka bytecode, computation core
-
gccjit_sys
Raw bindings to libgccjit. Companion to the gccjit crate.
-
maat_module
Module system and multi-file compilation for the Maat programming language
-
vexil-codegen-rust
Rust code generation backend for the Vexil schema compiler
-
nyar-assembler
Modern Nyar VM assembler - strongly typed, object-oriented, zero-dependency core
-
lux-lang
The Lux programming language
-
spaik
Programming Language
-
dpr
Dynamic parser and replacer. You can define rules at run time. It's possible to use peg format
-
proto-vulcan
A miniKanren-family relational logic programming language embedded in Rust
-
slasherc
A programming language for school, built in Rust
-
bitis
Bitwise serialization of messages defined in a data description language with interfaces for rust, python and c++
-
vexil-codegen-go
Go code generation backend for the Vexil schema compiler
-
b2c2-compiler
b2c2におけるBASICコードをCASL2に変換する部分?
-
y-lang
Compiler & Interpreter for the (rather new and very experimental) Y programming language
-
py-declare
type declare system for pycc-rs
-
swamp-compile
Main driver for the Swamp compiler, orchestrating bootstrapping, dependency loading, parsing, and semantic analysis phases
-
rajac-verification
OpenJDK compatibility verification runner for rajac
-
firmion-extension
Extension API used by the firmion compiler
-
shavenscript
Lightweight programming language made in rust with support for array and basic operations
-
brink-runtime
Runtime/VM for executing compiled ink stories
-
maat_eval
Tree-walking interpreter and macro expansion engine for the Maat programming language
-
vexil-codegen-ts
TypeScript code generation backend for the Vexil schema compiler
-
panproto-llvm
LLVM IR protocol definition and lowering morphisms for panproto
-
hacspec
compiler
-
stella_checker
Rust-based, speedy Lua type checker
-
airlang_ext
The Extension of Air Programming Language
-
spydecy
Self-hosted Python/C-to-Rust compiler-debugger with introspective debugging
-
mux-lang
The Mux Programming Language Compiler
-
phptaint
Security-focused PHP lexer, parser, AST, and configurable taint analysis engine
-
decy-ownership
Ownership and lifetime inference for C-to-Rust conversion (CRITICAL)
-
sapphire-lang
Gradually typed scripting language where every value is an object and types are optional, checked at runtime
-
moa_types
通用类型与宏定义
-
forked_react_compiler_utils
Rust port of the React Compiler, vendored from react/react
-
plato-dynamic-locks
Runtime lock accumulation — learns constraints from compilation/experience runs, extending static gates with dynamic knowledge
-
edlc_docs
HTML renderer for documentation for the EDL compiler
-
sap-ast
The abstractact syntax tree crate for the SAP programming language
-
seraphine-core
Core of the seraphine programming language
-
windjammer
language inspired by Go, Ruby, and Elixir that transpiles to Rust - 80% of Rust's power with 20% of the complexity
-
cranefack
An optimizing brainfuck compiler
-
cuda_builder
Builder for easily building rustc_codegen_nvvm crates
-
onion-frontend
Compilation frontend for the Onion programming language - lexer, parser, and IR generator
-
qcs-sdk-python
Python bindings to qcs-sdk-rust
-
valua-transformer
AST mutation passes that lower Lua 5.5 features to Lua 5.1 equivalents
-
swamp-script-ast
ast types for swamp script
-
brink-ir
Intermediate representations for inkle's ink narrative scripting language
-
bashrs
Rust-to-Shell transpiler for deterministic bootstrap scripts
-
circomspect-program-structure
Support crate for the Circomspect static analyzer
-
go-parser
The parser of the Goscript project
-
error_ctx
Minimal context error crate with Temporary/Permanent status and compiler-enforced context on public APIs
-
plotnik-vm
Runtime VM for executing compiled Plotnik queries
-
telltale-vm
Bytecode VM for choreographic session type protocols
-
tinymist-task
Task model of typst for tinymist
-
pseudo_interpreter
A Pseudocode interpreter
-
mutica-compiler
Compiler library for the Mutica programming language
-
claw-cli
The compiler for the Claw language
-
saxaboom
Binding library for Metal Shader Converter
-
pl_0
pl/0 compiler implemented in rust
-
zako
Small IR utilities inspired by RVSDG
-
mist-analyzer
The Mist programming language Analyzer LSP
-
mica
user-friendly, embeddable scripting language
-
claw-common
The Claw language common types and functions
-
gollum-ast
Abstract-Syntax-Tree for the Gollum language
-
oakc
A portable programming language with a compact backend
-
irvm
A IR compiler target with a Rust friendly API that lowers to LLVM IR
-
valkyrie-parser
The hand write parser of valkyrie language
-
glslang-sys
Raw C bindings to glslang
-
boron-lang
efficient, compiled programming language
-
rustc-demangle-capi
C API for the
rustc-demanglecrate -
tur
Turing Machine Language - Parser, interpreter, and execution engine
-
llvm-ir-analysis
Static analysis on LLVM IR
-
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.
-
r55
compiler for R.txt android files
-
gluon_doc
The documentation generator for the gluon programming language
-
valua-parser
Recursive-descent Lua 5.5 parser for the valua transpiler
-
coe-rs
Type coercion
-
libket
Runtime library for the Ket programming language
-
airl-interp
Tree-walking interpreter for AIRL IR with 74 builtins
-
synoema-diagnostic
Synoema — programming language optimized for LLM code generation
-
py-ir
Pin1Yin1 ir implementation
-
brink-format
Binary interface between brink compiler and runtime
-
roost-lang
Interpreter library for the roost language
-
python-packaging
Python packaging primitives implemented in Rust
-
vbscript
lexer and parser
-
lithia
Embeddable and simple lisp dialect
-
apollo-ariadne
A fancy diagnostics & reporting crate
-
moss
Experimental Moss interpreter
-
nextjs_react_compiler_optimization
Rust port of the React Compiler, vendored from facebook/react
-
hern
A small language compiled to Lua for LuaJIT
-
oak-glob
Glob pattern language support for Oaks
-
miden-objtool
Inspect Miden package MAST forest sizes
-
MotoGarage_parser
A parser and interpreter for MotoGarage DSL, a language for managing motorcycle collections
-
remir_llvm
The LLVM binding for the Remir library
-
bfrunner
A Brainfuck interpreter in Rust, for shits and giggles. Not for production.
-
xlang_frontend
Frontend for XLang-Rust
-
aleph-syntax-tree
Aleph Syntax Tree structure
-
lumen-cli
The AI-Native Programming Language
-
litua
Read a text document, receive its tree in Lua and manipulate it before representing it as string
-
bcomp
A compiler for a subset of the BASIC language
-
moa_rand
xoshiro256++ 伪随机数生成器
-
marzipan
A macro processor for ZZT worlds
-
lumi-core
Core lumi library
-
hiko-syntax
part of the hiko ML-family scripting language
-
aegean
A fancy diagnostics & reporting crate
-
husk-parser
Parser for the Husk programming language
-
moto
motivated automation
-
specl-tla
TLA+ parser and translator to Specl
-
fidget-bytecode
Bytecode representation for Fidget expression tapes
-
tket-qsystem
TKET tool for preparing and validating
Hugrs for compilation targeting Quantinuum H-series quantum computers -
symboscript-formatter
SymboScript formatter
-
leo-interpreter
Interpreter for the Leo programming language
-
wesley-emit-rust
AST-based Rust emitter for Wesley IR
-
rusty-basic
Tiny BASIC interpreter written in Rust
-
beadie-llvm
LLVM JIT backend adapter for beadie (via inkwell)
-
metaltile-macros
Proc-macro crate providing the #[kernel] DSL for MetalTile GPU kernels
-
genotype_lang_rs_core
Genotype language Rust target core crate
-
kasl-cranelift-backend
Backend implementation of KASL for Cranelift
-
codemem-index
Tree-sitter code indexing for Codemem memory engine
-
pyoxidizer
Package self-contained Python applications
-
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.
-
ty-parser_sln
SLN-syntax parser for the Ty programming language
-
dark-vm
A new VM called the DarkVM, which focuses on speed and simplicity
-
spydecy-optimizer
Cross-layer optimizer for Spydecy transpiler with boundary elimination
-
beadie-cranelift
Cranelift JIT backend adapter for beadie
-
moonjuice-common
Shared types and helpers for MoonJuice
-
swamp-script-node
compiler node with documentation and meta information
-
ezc
A compiler for ez
-
mini-c-parser
minimal C language lexer & parser & virtual executer from scratch
-
gramma
Generate a scannerless parser by declaring types
-
moore-common
The common core of the moore compiler framework
-
bwd
Backwards linked-lists
-
mir-rs
FFI bindings to MIR Project (https://github.com/vnmakarov/mir)
-
lilac
Static site generator-esque tool for adding include statements to HTML
-
impc
A compiler for the IMP programming language
-
torq_lang
A programming language for concurrent dataflow
-
ryna-language
An extensible programming language with a strong type system
-
firmion-extensions
Standard extension registration used by the firmion compiler
-
laburnum-syntax-macro
Proc-macros for defining CST and AST node types in language frontends built with the laburnum LSP framework
-
brink-codegen-json
JSON codegen backend: LIR → ink.json format
-
rythonc
A command-line Python to Rust compiler, at this point, very incomplete
-
stck-interpreter
An interpreter for the stck language
-
stormchaser-dsl
A robust, distributed workflow engine for event-driven and human-triggered workflows
-
go-types
The type checker of the Goscript project
-
abrase-cli
CLI for the Abrase language
-
jit-codegen
Code generator for arm64jit instruction metadata
-
glua_parser
Parser for Garry's Mod Lua, Lua 5.x, and LuaJIT source files
-
bfdbg
A brainfuck interpreter and debugger implemented in rust
-
synoema-repl
Synoema — programming language optimized for LLM code generation
-
send-future
Ergonomic and performant fix for https://github.com/rust-lang/rust/issues/96865
-
decomp
Components of a decompilation pipeline
-
polka-rs
Bytecode schema for the Myriad runtime (Abrase language)
-
llts_codegen
LLTS codegen — LLVM IR generation via Inkwell
-
chimpanzee
Monkey programming language implementation (interpreter, compiler and formatter), with added features
-
nextjs_react_compiler_hir
Rust port of the React Compiler, vendored from facebook/react
-
ocelot-interpreter
Interpreter for the ocelot project
-
pushr
based interpreter for Push programs
-
bock-pkg
Package management for Bock projects, including dependency resolution and lockfiles
-
rosetta-stone-smalltalk
Smalltalk language frontend for Rosetta transpiler
-
argmin_testfunctions
Test functions for optimization algorithms
-
elworthy-expr
Symbolic expression AST, canonicalisation, and CSE for elworthy
-
brink-analyzer
Cross-file semantic analysis for inkle's ink narrative scripting language
-
tos-tbpf
Virtual machine and JIT compiler for eBPF programs
-
rurust
High level Ruby VM bindings
-
py-codegen-c
C codegen backend implementation for Pin1Yin1
-
elworthy-weight
Bismut-Elworthy-Li weight synthesis for elworthy
-
sprout
growing simple, but beautiful AST trees 🌳
-
oxbuild
Ultra-fast typescript compiler
-
koopa
generating/parsing/optimizing Koopa IR
-
forked_react_compiler
Rust port of the React Compiler, vendored from react/react
-
macroassembler
writing portable x86-64/riscv64/aarch64 assembly code in Rust
-
steel-repl
REPL library for steel
-
claw-codegen
The Claw language Wasm code generator
-
ralix
type-safe, tree walking interpreter
-
hyeong
Hyeo-ung Programming Language Compiler
-
logic-ir
Universal Tri-Axial Fractal Topology (ZYModel) implementation in Rust
-
brink-intl
Internationalization tooling for brink stories
-
travis-cargo
Possible Rust replacement for existing Python travis-cargo
-
rasm-lang
RASM is a small Interpreted Programming Language
-
patchouly
A copy-and-patch JIT framework in Rust
-
crityp
Benchmark support for typst
-
ape_lexer
lexical analysis for Aperture programming language
-
ospl
the (UNFINISHED!!!) OSPL programming language
-
ptx_compiler
High level bindings to CUDA's ptx compilation APIs
-
morok-codegen
Backend code generation for the Morok ML compiler
-
brainfuck-cli
Brainfuck CLI interpreter written in Rust
-
lambdust
A Scheme dialect with gradual typing and effect systems
-
typiskt
Type systems as a library
-
libbfi
Extendable brainfuck interpreter library
-
bruto-pascal-lang
Mini-Pascal language implementation for bruto-ide
-
celsium
building interpreters
-
xlang_abi
ABI safe interfaces used by xlang
-
brink-converter
Converts inklecate .ink.json to brink .inkb format
-
cas-compiler
Bytecode compiler for CalcScript programs
-
intarsia
An extensible Rust optimization framework
-
regulus
interpreted language with very simple syntax and zero dependencies
-
safe_wren
A safe, pure-rust implementation of wren.io, drop-in replacement for wren.io's C implementation
-
bliplib
The Bizarre Language for Intermodulation Programming (BLIP)
-
rscheck-semantic
Semantic backend surface for rscheck
-
atlas_vm
The Atlas77 Virtual Machine
-
umbra-lang
macro-based scripting language
-
ast-grep-pyo3
Search and Rewrite code at large scale using precise AST pattern
-
relon-rs-shims
Runtime ABI shims for Relon AOT-compiled functions linked into Rust binaries
-
mrdo
A programming language (compiler, assembler, VM, and REPL) for working with collections of data
-
dust-lang
General purpose programming language
-
bock-errors
Diagnostic error types and source span machinery for the Bock language compiler
-
mijit
Experimental JIT compiler generator
-
nope-lang
The nope programming language
-
controlled-option
Custom Option type with explicit control over niches and memory layout
-
logicuniverse
Universal Tri-Axial Fractal Topology (ZYModel) implementation in Rust
-
zymodel
Universal Tri-Axial Fractal Topology (ZYModel) implementation in Rust
-
smpl
Core library to compile the SMPL language
-
retrolang-asm
Z80 assembler for RetroLang (based on FantASM by Guy Black)
-
calyx
Compiler Infrastructure for Hardware Accelerator Generation
-
nand7400
An assembler library for the nand7400 computer, created by me during my internship at the WCL
-
fnotation
lower-house syntax for programming language experimentation
-
portalis-transpiler
Python to Rust transpiler engine with WASM compilation support
-
lumic
Lumi compiler
-
scoutlang
A web crawling programming language
-
extendable_vm
that simplifies implementation of stack VMs
-
llvm-infra
LLVM Compiler Infrastructure in Rust
-
refrain-rhizome
Differential Refrain Engine: Loro CRDT bridge (optional)
-
valua-lexer
Lua 5.5 tokenizer for the valua transpiler (Lua 5.4 is a supported subset)
-
parsey
parser-generator framework
-
genotype_visitor
Genotype language visitor crate
-
brink-fmt
Source code formatter for inkle's ink narrative scripting language
-
bpf-ins
working with eBPF instructions
-
llvm-in-rust-transforms
Optimization and transformation passes for LLVM-in-Rust IR
-
rlx-mlx-sys
Low-level MLX C++ build + C ABI shim for RLX (vendored mlx, NVRTC-free)
-
yamlate
A cross-language interpreter library that dynamically evaluates YAML attributes given variable bindings
-
b2c2-parser
b2c2におけるBASICコードのパーサー?
-
vosh
General-purpose programming language
-
zul
General-purpose programming language
-
inline-vbs
Embed VBScript (and JScript, Ruby, Perl, ...) code inside Rust
-
galvan-ast
AST for the Galvan programming language
-
plexer
A Pattern-matching LEXER
-
tsar
Tsar programming language
-
sleuth
Extremely opinionated testing framework generating an exact specification and reducing code to its minimal implementation
-
brink-json
Parser for inklecate .ink.json output format
-
destack-rs
Rust compatibility crate for Destack
-
egglang
The Egg Programming Language From Eloquent JavaScript, but in Rust
-
cilk
(Toy) Compiler Infrastructure inspired by LLVM
-
lsp4spl
Language Server for SPL
-
oxc_ast
A collection of JavaScript tools written in Rust
-
diplomat_core
Shared utilities between Diplomat macros and code generation
-
craneliftc
light c compatible ffi wrapper around cranelift
-
callisp
A lisp interpreter that can be used with WASM
-
annotated-string
String with ability to annotate (format) its individual fragments
-
somni
scripting language and VM
-
diatom-std-core
Diatom core standard library
-
xlang_vm_core
XLangVM for XLang-Rust
-
wesl-c
C bindings for the WESL compiler
-
calyx-opt
Compiler Infrastructure for Hardware Accelerator Generation
-
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.
-
dynamik
A fast, powerful, expressive and typesafe language
-
slothlang
A weird, slow and a bit moldy interpreted programming language
-
syntax-parser-generator
Independent library for generating lexical-analyzers and LALR parsers
-
lexviz
A customizable lexical analyser tool which also allows you to visualize the NFAs and DFAs generated
-
sila-transpiler-infrastructure
transpiler infrastructure for every platform
-
decy-debugger
Interactive debugger for Decy C-to-Rust transpiler with spydecy integration
-
langkit
A builder library for creating programming languages in Rust
-
fr
A programming language with an unusual compiler backend
-
tatara-lisp-script
tatara-script — standalone interpreter that makes tatara-lisp a full scripting language for nix-run apps. Wraps tatara-lisp-eval with a scripting-oriented stdlib (http, json, yaml…
-
wander
scripting language
-
conventional_commits
A lightweight parser following the conventional commit standards
-
diplomat-tool
generating FFI bindings for various languages
-
ashpaper
Rust Inpterpreter for Esopo language AshPaper conceived by William Hicks
-
pr47
A semi-experimental programming language. Still working in progress.
-
cxc
A high performance scripting language
-
alan-von-palladium
The Alan von Palladium Programming Language - A systems programming language combining Turing's correctness with von Neumann's performance
-
husk-ast
Abstract syntax tree definitions for the Husk programming language
-
Cecile
Cecile Programming Language that is designed to be simple, fast
-
worldinterface-flowspec
FlowSpec parser, validator, and compiler to ActionQueue DAG
-
erg_type
APIs for Erg types
-
simple-symbol
Convenient, basic String interning
-
sk-lang
The SK Programming Language interpreter
-
mago-semantics
PHP Semantics Checker
-
c2rust-refactor
C2Rust refactoring tool implementation
-
elworthy-diff
Symbolic differentiation for elworthy expression trees
-
sylt-parser
Parser for the Sylt programming language
-
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… -
oris
An interpreter for Monkey
-
lykn-cli
Lykn language CLI — scaffolding, building, testing, and publishing for Lykn projects
-
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
-
tsz-cli
CLI binaries for the tsz TypeScript compiler
-
brink-db
Incremental project database for inkle's ink narrative scripting language
-
emei
JIT/AOT backend codegen framework
-
jupnet_rbpf
Virtual machine and JIT compiler for eBPF programs
-
bhc-hir
High-level Intermediate Representation for BHC
-
fexplib
lower-house syntax for programming language experimentation
-
sddrs
Bottom-up Sentential Decision Diagram compiler library
-
funcscript
universal core runtime (Rust VM) with C ABI and CLI
-
logicaffeine-base
Pure structural atoms for logicaffeine - arena, tokens, spans
-
run-kit
Universal multi-language runner and smart REPL
-
flow_stdlib
Standard library for the Flow programming language
-
gonidium
A DSL compiler and REPL for typed numeric expression pipelines
-
cljrs-compiler
JIT (Cranelift) and AOT compiler backend for clojurust
-
lipstick
C
-
skiff
An immutability-first, functional scripting language with a friendly syntax and compiler/interpreter written in Rust!
-
brink-driver
Pipeline orchestration for the brink ink compiler
-
silkworm_err
Compiler diagnostics for silkworm
-
duskphantom-backend
Backend for DuskPhantom Compiler
-
ruski
combinator calculus
-
stak-file
File system for Stak Scheme
-
rust-bf
A Brainfuck interpreter, generator, REPL, and IDE written in Rust
-
qcvm
A QuakeC runtime designed to be embedded
-
sollua
An elegantly fast lua 5.4 parser
-
krnlc
Kernel compiler for krnl
-
llvm-alt
A wrapper for LLVM, a powerful library and toolkit for compilers
-
flaneur2020/pua-lang
a dialect of The Monkey Programming Language
-
language-reporting
Diagnostic reporting for programming languages
-
ara_parser
A fault-tolerant, recursive-descent parser for Ara Programming Language 🌲
-
maat_ast
Abstract syntax tree (AST) for the Maat programming language
-
llts_driver
LLTS driver — pipeline orchestration from TypeScript to native
-
stator_jse
Stator JavaScript engine core — parser, bytecode compiler, Maglev JIT, interpreter, GC
-
pfcl-parser
Parser for PFCL — pure functional language with content-addressed catalog
-
jit
Just-In-Time Compilation in Rust using LibJIT bindings
-
rajac-classpath
Classpath loading and symbol extraction for rajac
-
bhc-session
Compiler session state, options, and configuration for BHC
-
lolli-prove
Proof search for the Lolli linear logic workbench
-
ale_python_parser
Python Parser : generate Aleph Syntax Tree
-
tl-stream
Streaming and pipeline engine for ThinkingLanguage (Phase 4)
-
ternlang-lsp
LSP 3.17 language server for ternlang — hover docs, code completion, and live diagnostics for .tern files
-
fexpresso
A minimal Kernel/vau-calculus Lisp with first-class operatives and environment-based IO
-
vexpresso
A minimal Kernel/vau-calculus Lisp with first-class operatives and environment-based IO
-
sqry-classpath
JVM classpath analysis for sqry - bytecode parsing, build system resolution, and graph integration
-
dash-lang
interpreted language
-
intent-codegen
Skeleton code generator for IntentLang specifications (Rust, TypeScript, Python, Go, Java, C#, Swift)
-
finx
A fast, lightweight embeddable scripting language
-
airl-typecheck
Bidirectional type checker for AIRL IR with effect tracking
-
swift-precompiler
A precompiler for Swift that allows you to use additional macros, include files, and more
-
brink-compiler
Compiler for inkle's ink narrative scripting language
-
fervid_css
Transformer for Vue
<style>blocks -
NULL
Interpreter for the NULL language
-
mdl_monkey
Monkey programming language from https://interpreterbook.com/
-
minicode
Esoteric programming language
-
annotate-snippets
Format diagnostic reports, including highlighting snippets of text
-
glulx-asm
Assembler for the Glulx Virtual Machine for Interactive Fiction
-
nash-cli
The Nash programming language
-
bop-compile
Ahead-of-time Bop to Rust source transpiler
-
rlci
Overly-documented Rust-powered Lambda Calculus Interpreter
-
hornbeam
template engine (high-level crate for use in applications)
-
ilex
quick and easy lexers for C-like languages
-
easyjsc
easyjs to JS/wasm compiler
-
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.
-
silt-lua
A pure rust Lua interpreter and virtual machine
-
barfs
Befunge JIT
-
mutica-semantic
Semantic analysis library for the Mutica programming language
-
comet-rs
Rust eDSL for COMET: domain specific COMpiler for Extreme Targets
-
cow-parser
A parser for the esoteric Cow programming language
-
py-rustitude
create and operate models for particle physics amplitude analyses
-
tin
statically structurally typed embeddable programming language
-
ts-runtime-typechecker
A command line tool that generates ts/js typechecker functions from typescript types
-
flow_runtime
Runtime library for the Flow programming language
-
forgellm-codegen-metal
Metal GPU code generation for Apple Silicon inference in ForgeLLM
-
molt
Embeddable TCL interpreter for Rust applications
-
impral
A command parsing and evaluation library for a LISP dialect, specialized for commandline input
-
rocks-lang
Crafting Interpreters' Lox Language
-
flow_compiler
JIT and AOT compiler for the Flow programming language using Cranelift
-
lex-bytecode
Bytecode compiler + VM for Lex
-
ferropascal
A Pascal-to-Rust transpiler that converts Borland Pascal source code into idiomatic Rust
-
paijorot
interpreted programming language implemented in Rust. It's designed as a hobby project with unique 'brainrot' syntax. ***(FULLY AI WRITTEN)***
-
mini-brainfuck
A super small brainfuck interpreter and compiler
-
nusy-cranelift
V13: Graph-native Cranelift JIT frontend — CodeNode → CLIF IR
-
luallaby
Work in progress A pure-Rust Lua interpreter/compiler
-
controlmap-parser
(De)Serializer of
controlmap.txtin Skyrim -
garden-lang-parser
A live programming language
-
the-code-graph-parser
Multi-language source code parser for The Code Graph
-
ape_ast
abstract syntax tree for Aperture programming language
-
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… -
azure
Project root for all Azure SDK-related crates
-
palate_polyglot_tokenizer
A generic programming language tokenizer
-
bicycle_numerics
Compute numerics for bicycle circuits
-
stak-primitive
Stak Scheme primitives
-
rustpython-bytecode
RustPython specific bytecode
-
rajac-compiler
Compiler pipeline orchestration for rajac
-
python-assembler
Parse and write Python .pyc bytecode
-
lead_lang_interpreter
Interpreter of the Lead Programming Language
-
luajit
calling LuaJIT from Rust
-
aiscript-arena
safe, incrementally garbage collected arenas
-
elworthy-codegen
Cranelift lowering of elworthy expression trees
-
abacus
The mathemagical programming language
-
mitex-cli
CLI for MiTeX
-
darklua
Transform Lua scripts
-
scout-parser
A web crawling programming language
-
tattle
Error reporting for compilers
-
shape-jit
Tiered JIT compiler (Cranelift) for the Shape virtual machine
-
ldpl
LDPL 4.4 compiler in Rust
-
sqry-lang-python
python language plugin for sqry
-
rshyeong
Hyeong-lang interpreter
-
remolt
Embeddable TCL-ish interpreter for Rust applications
-
brainfuck-plusplus
A brainfuck interpreter and compiler with some extra functionality
-
clutils
A common library for building interpreter and compiler
-
flow_transpiler
Transpiler infrastructure for the Flow programming language
-
nadesiko3
Japanese programming language Nadesiko v3
-
rust-type-sizes
parsing for '-Zprint-type-sizes'
-
scaly
programming language
-
aspl
Programming Language
-
crusts-notxl
CRustS - From Unsafe C to safer Rust
-
ty-ree
AST definitions for the Ty programming language
-
s-expression
parser
-
rtk-rustc-driver
The rustc driver (don't use this directly) for Rust Type Kit - query Rust types and produce FFI types
-
grove-compiler
Season-based compiler pipeline with ternary bytecode — Spring→Summer→Autumn→Winter
-
rtlola-streamir
A framework for the compilation of stream-based languages through an intermediate representation
-
haskelujah-backend-cranelift
Cranelift native code backend for the Haskelujah Haskell compiler
-
findpython
Find python executables on your system
-
haskelujah-parser
Lexer, layout, and parser pipeline for the Haskelujah compiler
-
libbf
Brainfuck-like language library
-
harborc
A language that ports: targeting your thermostat, UFO, and kitchen sink
-
yggdrasil-shared
Yggdrasil Compiler core shared components
-
aleph2py
Transpiler Aleph to python
-
draxl-lower-rust
Lower validated Draxl Rust-profile files to ordinary Rust
-
xliff2
XLIFF 2.0 read/write library
-
brainoxide
An optimizing Brainfuck compiler/interpreter
-
kronk
interpreter - a silly, experimental language with surprisingly loud output
-
lia
A high-level language for Rust
-
sabre-lang
The sabre programming language
-
calcit_runner
Interpreter and js codegen for Calcit
-
rail-lang
A straightforward programming language. Rail is currently experimental and subject to drastic breaking changes.
-
hebi
A dynamic scripting language
-
hugr-llvm
A general and extensible crate for lowering HUGRs into LLVM IR
-
regen-lang
A language for defining languages
-
husk-dts-parser
TypeScript declaration file (.d.ts) parser for Husk
-
py-codegen-llvm
llvm codegen backend implementation for Pin1Yin1
-
csw-derive
Type system derivation engine for the Categorical Semantics Workbench - derive type theories from categorical structures
-
lolli-parse
Parser for the Lolli linear logic workbench
-
ttk91
A parser, compiler and emulator library for the TTK91 instruction architecture
-
husk-lang
The Husk programming language compiler
-
ksplang
interpreter
-
exers
compiling and running other code in sandboxed environment
-
rispy
A Lisp in Rust
-
rpg-compiler
A compiler library for the rpg esoteric programming language
-
sassers
A Sass compiler in Rust
-
jit-assembler
A multi-architecture JIT assembler library for runtime code generation
-
hydroper_jet_compiler
Hydroper Jet Language Compiler
-
py-codegen
pycc-rs codegen interface
-
libdusk
implements most of the compiler for the Dusk programming language, in library form
-
hugr-core
Quantinuum's Hierarchical Unified Graph Representation
-
scout-lexer
A web crawling programming language
-
lolli-extract
Term extraction for the Lolli linear logic workbench
-
haloumi-llzk
Haloumi backend to LLZK
-
mri-sys
Rust bindings to Mat'z Ruby interpreter
-
llts_frontend
LLTS frontend — oxc parser and semantic analysis wrappers
-
vexity
Tiny scripting language for hacking on abstractions of financial markets
-
jitvm
a tiny i64-only language with a bytecode interpreter and a hand-rolled x86-64 jit
-
trans_py_c
Python subset → C transpiler for OS kernel and embedded development
-
zub
A fast, stack-based virtual machine for dynamic languages, with an intuitive IR-builder, garbage collection and NaN-tagging
-
autophagy
AOT compiler for Rust
-
rustc_codegen_nvvm
A codegen backend for Rustc which targets the libnvvm CUDA library
-
binks
scripting language
-
typst-html
Typst's HTML exporter
-
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
-
haskelujah-core
Core language, desugaring, and simplification for the Haskelujah compiler
-
flow_parser
Parser for the Flow programming language
-
falsec-compiler
FALSE compiler
-
orchidlang
An embeddable pure functional scripting language
-
spydecy-codegen
Rust code generator for Spydecy transpiler - generates idiomatic safe Rust
-
pddl_rs
PDDL parser
-
oak-html
HTML markup language parser with support for web content and document structure processing
-
moparse
Modelica language parser
-
eerie-sys
Unsafe raw bindings to the IREE Compiler/Runtime
-
pitusya
Programming Language
-
god-graph
A graph-based LLM white-box optimization toolbox: topology validation, Lie group orthogonalization, tensor ring compression
-
funct
A small, functional, embeddable scripting language with a fully reified bytecode VM you can pause, snapshot, and resume
-
symboscript-lexer
SymboScript lexer
-
brainterpreter
An interpreter for a Bauble toy programming language
-
yes-lang
Scripting Language
-
bff
A complete Befunge 98 interpreter in Rust
-
fennec
Programming Language
-
symboscript-parser
SymboScript parser
-
leuchtkraft
A logical programming language
-
cyclang-parser
Cyclang is a toy language built in LLVM
-
definitely
Codepaths that are statically unreachable according to the compiler's intraprocedural control flow analysis
-
clac-lang
Reference implementation of Clac++, a simple stack-based postfix (reverse polish notation) calculator/programming language
-
tyr-backend_ty
Tyr to Ty compiler
-
badlang
Next generation stack-based programming language
-
mogi_cpu
CPU emulation core for MOGI
-
bfjit
Brainfuck JIT VM tutorial
-
spydecy-python
Python AST parser and transpiler frontend for Spydecy
-
beadie-core
Bead chain, broker, hotness policy, swap, and deopt — no JIT backend
-
metaltile-codegen
Metal Shading Language (MSL) code generator for MetalTile kernels
-
sap-cli
The command line interface for the SAP programming language
-
guardc
GUARD → FLUX verified compiler
-
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… -
lamina-ras
ras - as/GAS alternative. Cross-platform assembler: assembly source (.s) to relocatable object files (.o). Used by Lamina, usable standalone.
-
csw-core
Core categorical structures for the Categorical Semantics Workbench - define categories and derive type systems
-
llvm_stackmap
capable of parsing stack maps emitted by the LLVM compiler
-
garguile
guile bindings for rust
-
rohanasantml
An easy way to write your messy html code in a better way
-
rustlex_codegen
Syntax extension for RustLex
-
onlang
A programming language running on json or yaml
-
aivm
Artificial intelligence that embraces the hardware it runs on
-
agent-wire-compiler
Canonical Wire action compiler primitives for the agent-wire.com substrate
-
bytebeat-cli
An LLVM-powered program to JIT-compile bytebeats and play them through your speaker
-
theforce
A Star Wars inspired programming language
-
dashc
Compiler, lowering, and artifact generation for DashScene
-
leo-errors
Errors for the Leo programming language
-
dynasm-lib
A pure rust assembler, not a JIT. Used within direct-asm for maximum control over assembly.
-
expr-solver
Solves a mathematical expression while following precedence and associativity
-
shortlang
A programming language designed for code golfing
-
dismael
Disassembler for Asmodeus binary files with intelligent analysis
-
chicken_esolang
An interpreter for the esolang Chicken
-
typst
A new markup-based typesetting system that is powerful and easy to learn
-
elina
Safe, high-level Rust wrapper for ELINA
-
scrapile
A somewhat fully-fleged rust-like programming language that, surprisingly, compiles to scratch
-
swc_cli
Commandline for SWC
-
gnu-libjit
A safe rust wrapper around the libjit just in time compiler
-
ironplc-plc2x
Compiler front-end for ironplc
-
tur-cli
Command-line interface for Turing machine simulator
-
graphcal-eval
Type-safe, unit-aware, Git-friendly reactive programming language for engineering calculations
-
llir
LLVM IR Binding
-
csw-generate
Code generation for the Categorical Semantics Workbench - generate type checkers and interpreters from derived type systems
-
libxas
Extendable Assembler library
-
flow_transpiler_java
Java bytecode transpiler for the Flow programming language
-
lore
Flexible logic programming
-
vyre-lower
Substrate-neutral lowering: vyre Program → KernelDescriptor consumed by vyre-emit-* crates
-
calyx-utils
Compiler Infrastructure for Hardware Accelerator Generation
-
vue-oxc-parser
Covert Vue AST (vue-compiler-core) to JSX AST (oxc)
-
setjmp
/ longjmp support
-
wysk
A statically typed functional language with type inference, ad-hoc polymorphism, and an extensible operator syntax. Influenced by Rust, ML, and Haskell.
-
jonlang
basic scripting language made to learn rust
-
seer
symbolic execution engine for rust
-
virdant
modern hardware description language
-
brainease_transpiler
A brainf*ck-style programming language, but readable
-
hecate-bf
A brainfck to hasm compiler for the hecate vm
-
dez80
A Z80 instruction decoding and (dis)assembly library
-
betadin
programing language for research purposes
-
xlang_host
Interface for determining and using platform-specific properties of the host system
-
yggdrasil-parser
Yggdrasil parser by yggdrasil
-
langpipe
A flexible Rust library for building custom compilers and interpreters with a modular pipeline for lexing, parsing, transforming, optimizing, and generating code
-
fervid_transform
Transformations for the fervid crate
-
scriptplan-bash
Experimental Bash language parser and runtime for
-
lolli-codegen
Code generation for the Lolli linear logic workbench
-
calyx-stdlib
Compiler Infrastructure for Hardware Accelerator Generation
-
vexc
Compiler and toolchain for the Vex programming language
-
stainless_script
Visual node-based programming language
-
seher
official crate
-
cbe_rbpf
Virtual machine and JIT compiler for eBPF programs
-
calyx-ir
Compiler Infrastructure for Hardware Accelerator Generation
-
sylt-compiler
Compiler for the Sylt programming language
-
dragon_blade
A transpiler from Rust to Overwatch Workshop
-
rtlola2rust
A compiler from RTLola to Rust through StreamIR
-
b2c2-stat
デバッグ用にところどころで使ってるぽい
-
stck
An embeddable interpreted language written fully in rust
-
cargo-whynot
Cargo subcommand to discover why a function is unsafe
-
calyx-frontend
Compiler Infrastructure for Hardware Accelerator Generation
-
qxq
A playground for interpreters and JIT compilers
-
parser-c
Macros for parser-c
-
rustpython-pylib
A subset of the Python standard library for use with RustPython
-
diatom-std-os
The diatom programming language
-
math-jit
Compile arithmetic expressions to native code
-
terl
a general parser
-
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
-
lib-ruby-parser-ast
AST for lib-ruby-parser
-
bund_stdlib_text_classifier
Text classification using Bayes classifier for BUND programming language
-
sylt-std
Standard library for the Sylt programming language
-
rigz_vm
Stack based VM for rigz
-
cranelift-simplejit
JIT library backed by Cranelift
-
ullage
Programming Language
-
logi_code
A scripting language do executing combinational circuits
-
prql-compiler
PRQL is a modern language for transforming data — a simple, powerful, pipelined SQL replacement
-
aion-lib-num
Number related utilties
-
hematita
A memory safe Lua interpreter
-
bf
An optimizing Brainfuck interpeter and JIT compiler
-
claw-resolver
The Claw language name and type resolver
-
lolcode
C compiler
-
binpattern
binary code pattern extractor for yaras
-
seraphine-cli
CLI for the Seraphine programming language
-
hephasm
Assembler for Asmodeus architecture with macro support and extended instructions
-
lunar-lang
Lunar is a compiler that generate mruby bytecodes from Lua script
-
bock-air
Annotated Intermediate Representation (AIR) for the Bock compiler — typed, scope-resolved, effect-aware
-
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…
-
autolang
Auto is a programming language for automations in various scenarios
-
fxrazen
compiler
-
sourcemap-resolver
Sourcemap resolving library and CLI
-
airlang_bin
Air is a universal, reliable, and lean programming language
-
genotype_writer
Genotype language writer crate
-
ssa-reloop
Relooper tool for SSA IR
-
brainstem
A Brainfuck compiler and interpreter library, with a BrainStem frontend language
-
woojin
Woojinlang interpreter written as Rust
-
turbofuro_runtime
Runtime for Turbofuro visual programming language
-
catalyst_entities
Low level data-structures for multithreaded and incremental compilation
-
ilvm
An interpreter for an assembly-like language
-
vtl-rs
Very Tiny Language (VTL) in Rust, inspired by the historical VTL-2 on Altair 680b and others
-
rush-interpreter-vm
A rush interpreter leveraging a micro-compiler alongside a VM for its runtime
-
lolli-viz
Visualization for the Lolli linear logic workbench
-
tin-lang
tin: a statically structurally typed embeddable programming language
-
husk-types
Type definitions for the Husk programming language
-
polonius
Core definition for the Rust borrow checker
-
rigz_runtime
Handles parsing and converting rigz to its VM instructions (for syntax highlighting use tree-sitter-rigz instead)
-
darklua-demo
Transform Lua scripts
-
lucia-lasm
LASM - Lucia Assembly Language
-
mindfuck
Brainfuck interpreter in Rust
-
ojisan_fuck
Brain-fuck interpreter parsing emoji used by Japanese ojisans
-
basic-lang
The BASIC programming language as it was in the 8-bit era
-
oxc_module_lexer
A collection of JavaScript tools written in Rust
-
ruby-sys
Low level bindings to MRI, Matz's Ruby Interpreter
-
oters_lang
Language definitions and interpreter for the oters programming language
-
symboscript-types
A symbolic programming language SymboScript types
-
moore-svlog
The SystemVerilog implementation of the moore compiler framework
-
hel
HEL — Heuristic Expression Language: a deterministic, auditable expression language & parser, AST, builtin registry and evaluator
-
cranelift-reader
Cranelift textual IR reader
-
reporting
diagnostic reporting for compilers
-
brainease_lexer
A brainf*ck-style programming language, but readable
-
trees-lang
Official impl of Trees (programming-language), supporting only parsing code now
-
fervid_parser
Vue SFC parser for the fervid crate
-
zerodds-dlrl-codegen
DLRL Code-Gen-Helpers: emittiert Home/Object-Boilerplate fuer cpp/csharp/java/ts
-
kansei
programming language
-
alicorn
Rust embedding of the Alicorn compiler
-
py-lex
lex definition for pycc-rs
-
first_rs_001
这是一个新手项目
-
ellie_bytecode
Bytecode assembler/encoder/decoder for ellie language
-
bund_stdlib_analysis
Numeric and text analysis for BUND programming language
-
open-vaf
A compiler frontend for VerilogA aimed predominently at compact modelling
-
cang
A coin based interpeter
-
llvm-rs
A wrapper for LLVM, a powerful library and toolkit for compilers
-
cljrs-jit
In-process JIT compiler (Cranelift) for clojurust — Phase 10.1
-
baracuda-nvrtc-sys
Raw FFI bindings and dynamic loader for NVIDIA NVRTC (runtime CUDA-C++ to PTX compiler)
-
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.
-
ape_parser
syntax analysis for Aperture programming language
-
lazyk-rust
Interpreter for Lazy K programming language
-
brainfuckr
brainfuck interpreter written in Rust
-
lift-quantum
Quantum dialect — qubits (linear types), gates, noise attributes, layout mapping
-
ssa-cc
Traits for compiling SSA IR to C
-
typed-sf
Typed ready-to-use implementation of SmallF*ck language in Rust
-
llvm-pm-sys
Raw FFI bindings for LLVM new PassManager C++ stubs
-
badeline-plugin
Darkside reflection for Rust
-
compiler-builtins-snapshot
Snapshot of the compiler-builtins crate
-
synoema-codegen
Synoema — programming language optimized for LLM code generation
-
claw-ast
The Claw language Abstract Syntax Tree (AST)
-
hornvale
experimental, idiosyncratic text adventure game written in Rust
-
voce-validator
Voce IR reference validator and CLI toolchain
-
bsharp_lsp
The B# programming language!
-
brainfuck-exe
A brainfuck interpreter implemented in rust
-
cartes_rbpf
Virtual machine and JIT compiler for eBPF programs
-
relo
A custom programming language with a readable syntax (RELO)
-
synox
Program synthesis of string transformations from input-output examples
-
jzero
A compiler and bytecode VM for the Jzero language (a subset of Java)
-
moore-circt
Rust wrappers around the CIRCT API
-
walnut
Walnut File Systwm Experimental file system with inode level encryption
-
yagbas_asmtypes
The assembly data type for the yagbas compiler
-
sp1-recursion-compiler
Compiler for SP1 recursion circuits
-
numlang
A compiler for an esolang that uses hexadecimal
-
hyperparse
A HyperText Markup Language (HTML) parser written in Rust. (WIP)
-
metaltile-core
Core IR types and data structures for the MetalTile GPU kernel DSL
-
depyler-graph
Dependency graph analysis for Python-to-Rust transpilation error reasoning
-
lua_engine
lua engine
-
brainfork
A compiler for Brainfuck written in Rust
-
llk
A fast, little an easy to understand LL(k) (LL(1) for now) library and compiler compiler (soon)
-
symboscript-optimizer
SymboScript optimizer
-
monkey-rs
Monkey programming language interpretter
-
luna-lib
a light weight interpreted programming language
-
hydroper_razen
Razen MXML compiler
-
sylt-typechecker
Typechecker for programs in the Sylt programming language
-
scurry
A component-based object-oriented language
-
rustc-hex-viewer
compiler as a hex viewer
-
mlua-image
Lua bindings and embedding of the Rust based 'image' imaging library
-
mica-hl
High-level interface to the Mica scripting language
-
fervid
Vue SFC compiler written in Rust
-
dunh
Highlights code for printing
-
nexus-lib
The raw implementation of the nexus scripting language
-
xasm
Compiler for the xasm programming language
-
lovm2
a lightweight virtual machine with a focus on simplicity and extendability
-
dlang
Programing language from scratch
-
sap-lexer
The lexer crate for the SAP programming language
-
bitsyc
Bitsy compiler written in Rust
-
rpiet
An interpreter for Piet, the esoteric programming language
-
genotype_json_schema
Genotype language JSON Schema crate
-
bfup
Preprocessor for brainfuck-like languages
-
msiz_rustc-ap-rustc_target
Automatically published version of the package
rustc_targetin the rust-lang/rust repository from commit 74d5c70b174f06843049af2d764ff57ddc81c81c The publishing script for this crate lives at: https://github… -
ruschm
Scheme(R7RS-small) interpretor/compiler rust implementation
-
ara_source
A Source library for Ara Programming Language 🗃
-
uwcl_rbpf
Virtual machine and JIT compiler for eBPF programs
-
fervid_napi
Vue SFC compiler written in Rust
-
bsharp_ir
The B# programming language!
-
ternlang-core
Compiler and VM for Ternlang — balanced ternary language with affirm/tend/reject trit semantics, @sparseskip codegen, and BET bytecode execution
-
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
-
calyx-backend
Compiler Infrastructure for Hardware Accelerator Generation
-
gitrevset
A domain-specific-language to select commits in a git repo. Similar to Mercurial's revset.
-
mango
programming language (UNDER CONSTRUCTION)
-
leo-span
Span handling for the Leo programming language
-
portal-pc-waffle-frontend
Frontend (Wasm to IR) for the WAFFLE Wasm analysis framework
-
target-lexicon
LLVM target triple types
-
cxx-llvm
cxx-style FFI bindings to the LLVM C++ API
-
cyclang-backend
Cyclang is a toy language built in LLVM
-
reproto
compiler
-
linguist-rs
that can be used to detect programming languages
-
jsompiler_common
Common utilities for jsompiler
-
malbolge
Programming Language in Rust
-
sap-interpreter
The interpreter crate for the SAP programming language
-
vicis
Manipulate LLVM-IR in Pure Rust
-
swc_js_sourcemap
Basic sourcemap handling for Rust
-
leo-abi-types
ABI type definitions for Leo programs
-
tiny_lang_parser
A tiny language parser and interpreter for simple math expressions
-
c-emit
Polished builder API to write C Code
-
rush-parser
A lexer and parser for the rush programming language
-
llvm-sys-featured
Bindings to LLVM's C API
-
spl_frontend
Compiler-Frontend for SPL
-
typed-eval
A type-safe expression evaluation engine
-
mindblown
Brainfuck to x86 ELF compiler with batteries included
-
OOLANG
An esoteric stack-based programming language, where all instructions are different variations of the character 'O'
-
laspa
Lisp-like language built with Rust
-
rust-scheme
Scheme(R7RS) interpretor/compiler rust implementation
-
lld_rs
Bindings for LLD
-
sap-parser
The parser crate for the SAP programming language
-
molt-ng
Embeddable TCL interpreter for Rust applications ()
-
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… -
kind-pass
A lot of compiler passes for the kind compiler
-
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.
-
cranelift-object
Emit Cranelift output to native object files with
object -
stak-minifier-macro
Macros to minify Stak Scheme source codes
-
fortraith
Compile-time compiler that compiles Forth to compile-time trait expressions
-
rush-analyzer
A semantic analyzer and type-annotator for the rush programming language
-
lift-export
Backends — LLVM IR, ONNX (opset 21), OpenQASM 3, CUDA PTX (planned), XLA (planned)
-
typeslice
type-level slices
-
kz80_smalltalk
Tiny Smalltalk to Z80 compiler for RetroShield hardware
-
tinymist-core
Tinymist core library
-
compile-in-memory
dynamically compile and load C/C++ code at runtime, using the platform's host compiler
-
satellite-jit
LLVM JIT compilation for ABI-OP constraints
-
tinylj
calling LuaJIT from Rust
-
selya
Specific Language for Young and Adult :D
-
synth-backend
ARM encoder, ELF builder, vector table, linker scripts, and MPU configuration
-
rtlola-streamir-interpreter
An interpreter for RTLola through StreamIR
-
string_cache_plugin
A string interning library for Rust, developed as part of the Servo project − compiler plugin
-
brainfrick
An optimizing brainfuck interpreter with helpful errors
-
jkl-lang
Open Source Programming Language
-
sym-lang
Sym Lang is a lightweight stack-based programming language that uses symbols and numbers
-
sieve-rs
Sieve filter interpreter for Rust
-
op8d_lexemizer
Opinionated library for transforming code to a vector of Lexemes
-
julia
Idiomatic and safe Julia bindings for Rust
-
blink_runtime
Runtime lib for creating plugins for blink
-
galvan-into-ast
CST to AST conversion for the Galvan programming language
-
koi-gc
koi programming language garbage collector
-
pcre2-sys
Low level bindings to PCRE2
-
cluna
convert Lua code into Clue code Made by MarkosTh09
-
genotype_lang_core_codegen
Genotype language target codegen crate
-
brainfuck
interpreter and modules
-
luajit2-sys
LuaJIT-2.1 FFI Bindings
-
libicsneo
Rust API for libicsneo
-
loxcraft
A compiler, VM, language server, and online playground for the Lox programming language
-
brainfuck-hcy
My First Rust Project : A Brainfuck Interpreter, Comprehensive and Easy to Read
-
quench
A programming language
-
pk_parser
The Palacinke lang parser
-
rspack_hash
rspack hash
-
gibberish-core
Core types and functions for Gibberish parsers
-
dora
programming language
-
pk_compiler
The Palacinke lang bytecode compiler
-
bsharp
The B# programming language!
-
script-format
DSL to format data via rhai scripting
-
codegem
A small code generation library
-
lexariel
Lexical analyzer for Asmodeus language
-
psilva_functions
Bibliotetca de funções do Psilva
-
fbp
Flow Based Programming for the Rust language
-
lmntalc-core
Backend-neutral compiler core for lmntalc
-
seq-compiler
Compiler for the Seq programming language
-
syntax-rs
parsing programming languages
-
leftpad-str
Obviously the best crate for the Rust programming language. The crate serves the only goal of implementing
leftpadfunction. -
fennec-vfs
Fennec Programming Language
-
draxl-cli
Command-line interface for Draxl
-
lemonlang
an experimental, modern, purely safe, programming language
-
simple-script-compiler
A tiny simple script language compiler/interpreter for learning and testing
-
kind-target-kdl
KDL target for the kind compiler
-
llvm-scratch
Free Standing library in Rust
-
songe
Interpreter for a Scheme-like language for graphics and games
-
citadel-frontend
The frontend of the citadel compiler backend
-
dolang
Embeddable public API for the Do language
-
bsharp_tokens
The B# programming language!
-
big-code-analysis
compute and export code metrics
-
rivescript-core
Core data types and traits for RiveScript
-
cbqn-sys
FFI bindings to CBQN
-
litto
Building blocks for DSL scripting language interpreters that interact with native Rust code
-
gs2compiler
Compiles GS2 source code into GS2 bytecode
-
parsentry-core
Core types and traits for Parsentry
-
rustycpp
An attempt to implement the C++20 standard. This is mostly to have fun & learn rust
-
carlo
interpreted programming language
-
typst-syntax
Parser and syntax tree for Typst
-
ext-string
An attempt to extend rust String struct with functionality from other programming languages
-
moore-svlog-hir
The HIR of the SystemVerilog implementation of the moore compiler framework
-
px-llvm-codegen-utils-core
Core traits for LLVM codegen utilities
-
koi-parser
koi programming language parser
-
sqry-lang-haskell
Haskell language plugin for sqry
-
cas-vm
Virtual machine that executes CalcScript bytecode
-
ial-ast
ial's Abstract Syntax Tree
-
dependency_lister
Tools to list dependencies from .d files generated by clang or GCC
-
rigz_ast
AST parser for the rigz programming language
-
genotype_lang_rs_visitor
Genotype language Rust target visitor crate
-
t-parser_sln
SLN-syntax parser for the T programming language
-
genotype_lang_ts_converter
Genotype language TypeScript target converter crate
-
vue-compiler-core
Vue compiler in Rust's core component
-
quail
Programming Language
-
rcc4r
C compiler implemented in Rust with only 4 raw-functions
-
likeness
Stable counterparts to likeness core instrinsics in Rust
-
bsharp_fset
The B# programming language!
-
bftextmaker
generate brainfuck code that prints out a given string
-
tl-ast
Abstract Syntax Tree definitions for ThinkingLanguage
-
sateko
A toy brainfuck compiler
-
hiko-types
part of the hiko ML-family scripting language
-
gnulightning-sys
Rust bindings for gnulightning jit compiler
-
stak-macro
Macros to integrate Stak Scheme
-
lua-types
A Lua 5.4 interpreter implemented in safe Rust
-
surplus-cli
CLI for the Surplus JSX compiler
-
autophagy-llvm
LLVM backend for Autophagy
-
smpli
Interpreter for the SMPL language
-
zust-dynamic
Dynamic value model for Zust scripts, with JSON, MessagePack, bytes, and typed vectors
-
bpf-script
A small scripting language and compiler for creating eBPF programs at runtime
-
lora-compiler
Query-plan compiler for LoraDB's Cypher implementation
-
bsharp_parser
The B# programming language!
-
sylt-common
Common denominator for the Sylt programming language crates
-
seq-core
Core runtime library for stack-based languages (Value, Stack, Channels)
-
rs-luau
Minimal overhead Luau bindings for Rust!
-
jeff-format
Rust bindings for the jeff exchange format
-
sqry-lang-c
C language plugin for sqry
-
ferrum_compiler
Compiler library for the Ferrum programming language
-
lincoln
A low level programming language features linear types and direct manipulation of continuation (returning points)
-
ils
Directly read directory in image files
-
bfmod
Brainfuck lexer and compiler library for Rust
-
xrcf
eXtensible and Reusable Compiler Framework
-
htn_planner
HTN parser and planner
-
prism-compiler
An adaptive and functional programming language
-
slashes
A /// interpreter written in Rust
-
chomatter_cli
Compiler for the language
-
codelighter
A fast error, warning and notes highlighter for Rust
-
toylang
CLI/Wrapper
-
bytebraise-syntax
BitBake parsing, syntax, and AST definitions for bytebraise
-
symjit
a lightweight just-in-time (JIT) optimizer compiler
-
llvm-ir-taint
Taint tracking for LLVM IR
-
liblox
VM of the lox language
-
yggdrasil-error
Yggdrasil shared error handlers
-
dpy
transpiler to translate dutch python like code to working python code
-
haloumi-ir-base
Types used by the IR and by some modules that the IR depends on
-
bytevm
A tiny bytecode virtual machine
-
trashcan
language which compiles to Visual Basic 6 / VBA
-
mlua-xid
A Rust-native binding for the 'xid' crate for Rust
-
tlisp
Lisp interpreter in Rust
-
intarsia-build
Build helpers for compiling ISLE rulset files in build scripts for Intarsia optimizers
-
kind-checker
Type checker for the kind compiler
-
paranoia
Programmatically determine whether code was optimized away or not
-
genotype_lang_ts_codegen
Genotype language TypeScript target codegen crate
-
liexpr
parsing and evaluating simple expressions
-
fennec-common
Fennec Programming Language
-
oak-scheme
Scheme functional programming language parser with support for Lisp dialect and symbolic computation
-
ryft-core
Core abstractions of the Ryft library
-
ugo
uGo Compiler
-
luaparser
Read Lua 5.1 code and produce an abstract syntax tree
-
rumya-binding
Rumya programming language's binding for Rust
-
decy-core
Core transpilation pipeline for C-to-Rust conversion
-
norn
High-level compiler library
-
clue_core
C/Rust like programming language that compiles into Lua code
-
slj
Programski jezik v slovenščini | A programming language in Slovenian
-
mago-names
Resolves and normalizes identifiers (classes, functions, constants) within PHP code
-
haskelujah-backend-llvm
LLVM IR backend for the Haskelujah Haskell compiler
-
flycatcherc
The front-end of the Flycatcher compiler
-
ubpf-assembler
eBPF assembler and JIT compiler for ubpf
-
rustpython-parser
Python language parser for Python3
-
relon-analyzer
Semantic analysis layer for the Relon language: name resolution, schema desugar, diagnostics
-
oxerun
Compiler bits to create Rust unikernels for Xen
-
intcode_compiler
AoC 2019 Intcode compiler, interpreter and transpiler
-
blink_core
Core interpreter for the Blink Lisp dialect
-
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
-
oxc_allocator
A collection of JavaScript tools written in Rust
-
clear-cache
A native implementation of
__builtin___clear_cachewithout dependency of GCC/Clang -
bif
Brainfuck Compiler
-
pulley-interpreter
The Pulley interpreter, its bytecode definition, encoder, decoder, and etc
-
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!
-
nextjs_react_compiler_lowering
Rust port of the React Compiler, vendored from facebook/react
-
bsharp_interp
The B# programming language!
-
koto
expressive, embeddable programming language
-
tools_core
Core functionality and schema generation for the tools collection system
-
zenforks-cubecl-cpp
CPP transpiler for CubeCL
-
haloumi-core
Core types and traits of the Halo2 frontend for LLZK
-
monkey-lexer
a lexer for monkey lang
-
kind-span
Describes locations for the Kind compiler
-
crispy
a lisp enterpreter
-
ezjs
micro Javascript (ES5) engine is Rust
-
ablescript
The best programming language
-
starfish
*><> is a stack-based, reflective, two-dimensional esoteric programming language based directly off of ><>
-
lex-store
Content-addressed on-disk store for Lex stages, branches, and traces
-
genotype_runtime
Genotype runtime
-
stir
Small Threaded Intermediate Representation
-
rusty_utils
package that provides utility functions inspired by or ported from other programming languages
-
sqry-lang-javascript
JavaScript language plugin for sqry
-
petr-ir
target agnostic IR for the petr language
-
stak-process-context
Process context for Stak Scheme
-
luah
Unofficial lua impl by HydroRoll-Team
-
nlcc
Nameless C Compiler
-
sqry-lang-shell
Shell script language plugin for sqry
-
eirproject/libeir_syntax_core
Erlang ecosystem common IR
-
xassembler
Compiler tools for the xasm programming language
-
seq-runtime
Runtime library for the Seq programming language
-
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
-
symboscript-utils
SymboScript utils
-
tale
A Scripting language for TTRPG Tables
-
ratel
JavaScript transpiler in Rust
-
depyler-core
Core transpilation engine for the Depyler Python-to-Rust transpiler
-
rustyscript
Effortless JS Integration for Rust
-
oak-csharp
C# frontend for Oak
-
lisper
Lisp interpreter in Rust
-
stationeers-mips
Intermediate representation for Stationeers MIPS assembly
-
ptoxide
A virtual machine to execute CUDA PTX without a GPU
-
logo-runtime
Implements the runtime for graphic functionality of Logo programming language
-
sylt-machine
VM for running programs in the Sylt programming language
-
mochi-lang
concatenative programming language
-
vermilion-vm
A virtual machine written in Rust
-
blazefuck
A blazingly-fast (interactive) Brainfuck interpreter
-
bril-frontend
AST and type-checking for Bril programs
-
rustd_backend_llvm
LLVM backend for RustD deterministic DSL compilation
-
ano_jit_bfi_rs
Outdated Just-In-Time BrainFuck Interpreter written in RuSt
-
tenda-reporting
Reporting utilities for the Tenda programming language
-
galvan-parse
The parsing crate for the compiler of the Galvan programming language
-
air-script-core
Core types for the AirScript compiler
-
artlr_syntax
syntax analysis
-
melbi
expressive, embeddable, sandboxed expression language
-
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
-
parsanol
High-performance PEG parser library with packrat memoization and arena allocation
-
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
-
gluac-rs
compiling Garry's Mod Lua into bytecode
-
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
-
tml_parser
The official parser for the TML language
-
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:… -
mica-language
Reference implementation of the Mica scripting language
-
swc_ecma_transforms_proposal
rust port of babel and closure compiler
-
yagbas_asttypes
Abstract Syntax Tree type (and parser) for yagbas
-
blitz_lang
A Hobby Programming Lang with Rust
-
rlisp
experimental lisp interpreter in rust
-
hzlang_parser
A parser for the "hz" programming language
-
oil-lang
OIL
-
rustpython-literal
Common literal handling utilities mostly useful for unparse and repr
-
c64-assembler-6502
Definition of 6502 instruction set
-
gust-lsp
Language Server Protocol (LSP) implementation for the Gust state machine language
-
kaon
A little scripting language written in rust
-
citadel-api
The api for the citadel compiler backend
-
cowlang
Python-like scripting language
-
diatom-cli
The diatom programming language
-
hlvm
/ tools
-
chan-lang
Chan Programming Language
-
celestial-hub-compass
ETAC compiler
-
libsix
Compact programming language built on top of Rust ecosystem
-
numeron
Neron is a language designed to be as simple as possible
-
tinymist-lint
A linter for Typst
-
swc_ecma_transforms_react
rust port of babel and closure compiler
-
petr-profiling
tools for profiling the performance of the petr compiler
-
patch-rexx
A modern REXX interpreter in Rust
-
flow_lexer
Lexical analyzer for the Flow programming language
-
metals
A meta programming language for Composable Systems
-
wedpr_ffi_macros
WeDPR ffi shared macros
-
xlang_targets
ABI Safe Interfaces for target triples and discovering compiler-required information about targets
-
neptune-lang
An embeddable scripting language
-
ape_errors
error handlers for Aperture programming language
-
cxx-llvm-build
Common build code for cxx-llvm
-
lia-plugin
Compiler plugin for writing Lia code as a macro
-
aprender-verify-ml
Synthetic Data Factory for Domain-Specific Code Intelligence
-
nodarium_utils
A collection of utilities for Nodarium
-
symboscript-interpreter
SymboScript interpreter
-
sora-diagnostics
powerful configuration table compiler for games and data-heavy tools
-
bomlamaal
Bømlamål as a programming language
-
rascal_scanner
Rascal programming language scanner
-
ion-derive
Derive macro for Ion scripting language host types
-
xlsynth
Accelerated Hardware Synthesis (XLS/XLSynth) via Rust
-
bicycle_compiler
A compiler for Pauli-based compilation (PBC) circuits to bicycle instructions
-
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
-
orecc-front
compiler frontend utility toolkit
-
carlo-help
A help utility for the simple interpreted programming language Carlo
-
carlo-run
A runner for the simple interpreted programming language Carlo
-
carlo-repl
A REPL for the simple interpreted programming language Carlo
-
carlo-version
Version for the simple interpreted programming language Carlo
-
tenda-parser
Parser for the Tenda programming language
-
swc_experimental_ecma_parser
An extensible Rust-based platform for the next generation of fast developer tools
-
flycatcher-parser
The Flycatcher programming language's parser
-
crain
A Brainfuck compiler/interpreter/tool
-
request_compiler
Request Compiler Optimized for Batching Requests
-
vermilion_jit
A toolkit for JIT compilation
-
rascal_bytecode
Rascal programming language bytecode
-
tt-toolkit
A collection of macros for rapidly prototyping programming languages
-
vm_lang
interpreted language written in Rust
-
cemc
Cem language compiler - A concatenative language with green threads and linear types
-
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!
-
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
-
sp1-constraint-compiler
Constraint compiler for SP1 core machines
-
dibs-qgen
Query DSL code generator for dibs (parses .styx query files into Rust and SQL)
-
rascal_parser
Rascal programming language parser
-
extern-existential
Rust extern existential types prototype
-
mtots
scripting language
-
enalang
Exhaustingly Notorious Algorithms - umbrella package
-
swc_compiler_base
Base crate for the 'swc' crate. This is not a public API.
-
lucia-lang
Lucia programming language
-
remarklib
The core of the Remark programming language
-
rustc_get_version
rust compiler get version utility
-
lib_stacked
Virtual Machine Byte Code For Compilers
-
kz80_microperl
A minimal Perl interpreter and compiler for RetroShield Z80
-
kind-query
Query module for the kind compiler
-
mir-sys
FFI bindings to MIR Project (https://github.com/vnmakarov/mir)
-
rustpython-sre_engine
A low-level implementation of Python's SRE regex engine
-
cte_ir
Compile-time evaluation IR
-
golang-type
Golang Type
-
code-gen
aids in code generation
-
orbitc
The Orbit Compiler Infrastructure
-
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
-
ra-ap-rustc_lexer
Automatically published version of the package
rustc_lexerin the rust-lang/rust repository from commit 61d7280f3c4c63fa24c56bdaa9a446151b5a30dc The publishing script for this crate lives at:… -
c-lang
Scripting language made in rust
-
mangle
Exolang that can take any utf8 text as valid code and return some result out of it
-
test_zia
Test Library for the Zia Programming Language
-
iaith
Implementing toy languages in rust
-
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
-
vize_croquis
Croquis - Semantic analysis layer for Vize. Quick sketches of meaning from Vue templates
-
coopted_llvm_sys
Coöpt rustc‘s own LLVM to do fancy stuff with it
-
shulkerscript
language implementation with compiler
-
toyc
The toylang compiler
-
sussy
pierwszy kwietnia
-
dylan
Dylan
-
typst-utils
Typst
-
the-super-tiny-rusty-compiler
A super tiny and rusty compiler
-
icelang
high-level programming language created for the purpose of learning about programming language design and implementation
-
ion_shell_parser
Parser for the scripting language of the ion shell
-
evcxr_jupyter
A Jupyter Kernel for Rust
-
koi-lang
🐟 High-level programming language 🐟 Cross-platform 🐟 Blazing performance 🐟 Static linking 🐟
-
rustycli
🦊 Access the rust playground right in terminal
-
robson_compiler
Dependency of the robson cli
-
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
-
mplbeem
Sync MPL-licensed projects
-
ape_expr
abstract syntax tree for Aperture programming language
-
hbc
Random program that does random stuff
-
cpprs
C pre-processor on Rust source files
-
skrusty
Translating C to Rust
-
vicuna-runtime
Runtime for the Vicuna programming language
-
crispr_guessing_game
My first small rust project
-
wmlua-src
wmlua
-
syntactic_heap
A framework designed for representing Abstract Syntax Trees
-
dimpact
impact analysis from diff
-
welly-parser
An artisanal parser for the Welly programming language
-
ncc
Compiler for custom modes on Novation MIDI devices
-
demi
An interpreter for the Demi programming language
-
intent-runtime
Expression evaluator and stateless runtime for IntentLang specifications
-
h2lang
H2 Language - A Herbert Online Judge compatible programming language with multi-agent support
-
tan-lang
namespace for tan-lang.org crates
-
js_parser
Javascript Parser : generate Aleph Syntax Tree
-
synth-cli
CLI for Synth, the WebAssembly-to-ARM Cortex-M AOT compiler
-
yagbas_srcfiletypes
types for reading in yagbas source files
-
cranelift-module
Support for linking functions and data with Cranelift
-
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
-
wasmer-clif-fork-simplejit
JIT library backed by Cranelift
-
maat_field
Finite field arithmetic and value-to-field encoding for the Maat programming language
-
tanlang
namespace for tanlang-org crates
-
spade-types
Helper crate for https://spade-lang.org/
-
lumen-vm
The AI-Native Programming Language
-
fck
Brainfuck parser, lexer and interpreter
-
rji
Generates an efficient and seamless Rust/Java bridge. A Rust-Java Interface.
-
boolfuck
unoptimized boolfuck interpreter which can convert brainfuck code
-
nl-compiler
AIG and Verilog frontend compilers
-
forgellm-codegen-cpu
CPU code generation (x86 AVX2/512, ARM NEON) for ForgeLLM
-
kind-report
Report module for the kind compiler
-
enalang_vm
Exhaustingly Notorious Algorithms - virtual machine
-
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
-
ljf
tutorials
-
rust-compile
Go on. Compile it.
-
boa_ast
Abstract Syntax Tree definition for the Boa JavaScript engine
-
rolldown_ecmascript
ECMAScript AST and parsing utilities for Rolldown
-
vk_execute_compiler
VK execute compiler
-
meadorc
meador scripting language compiler
-
gccarch
Report architecture information from GCC's backends list
-
progenitor-hk
An OpenAPI client generator
-
kodept
compiler with dependent types support in mind
-
moore-circt-sys
Low-level language bindings to CIRCT
-
new_project
Basic math operations
-
ryna-ffi
FFI interface for the Ryna Programming Language
-
logo-web
Web-based IDE for Logo programming language
-
wirespec
Type-safe protocol description language — compiler, verifier, and LSP
-
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
-
raic
Raic programming language — compiles to Rust
-
roto
a statically-typed, compiled, embedded scripting language
-
metaltile
Rust DSL for writing Apple Metal GPU kernels — write once, run fast on Apple Silicon
-
guile-scheme
A small wrapper around the Guile Scheme Extension and Scripting Language
-
avdl
Avro IDL compiler that turns .avdl into .avpr and .avsc JSON files
-
dwanim-state
Rust-core + Python DSL video renderer
-
App1
A sample Rust library project
-
swc_ecma_transforms_compat
rust port of babel and closure compiler
-
rsaeb
A no_std + alloc interpreter for A=B ordered rewrite programs
-
cfg_compiler
cfg setup
-
canadensis_dsdl_frontend
Compiler front-end for the Cyphal Data Structure Description Language
-
papyri-lang
Compiler for the Papyri markup language
-
stap-lang
Stap programming language (STAck Processor, ala Lisp)
-
forked_react_compiler_hir
Rust port of the React Compiler, vendored from react/react
-
rascal_compiler
Rascal programming language compiler
-
petr-resolve
resolution stage of the petr compiler
-
hush
unix shell scripting language based on the Lua programming language
-
swc_ecma_transforms
rust port of babel and closure compiler
-
fervid_core
The core structures and utilities of fervid
-
arbor-core
AST parsing and code analysis for Arbor
-
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
-
intent-parser
PEG parser and typed AST for the IntentLang specification language
-
kotlin-parser
Kotlin Language Parser (WIP)
-
paxforth
Pax Forth programming language for Pax Consola, a development environment for vintage computers and consoles
-
oak-nix
Nix package manager language parser with support for declarative package configuration and reproducible builds
-
voce-compiler-hybrid
Voce IR hybrid compiler — per-component target selection across DOM, WebGPU, and WASM
-
nodespeak
A JIT-ish compiler for number-crunching applications
-
ffmmlc
FFMML command-line compiler
-
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
-
petr-api
re-exports of useful APIs for the petr compiler
-
rspack
-
mallardscript
Hak5 DuckyScript extended language compiler
-
midenc-hir-opt
parsing and rewriting HIR
-
eirproject/libeir_intern
Erlang ecosystem common IR
-
as3razen
compiler
-
diatom-core
The diatom programming language
-
kz80_ws
WordStar clone for Z80 - Retro word processor on the RetroShield
-
teolang
A programming language design to be easy to learn for kids
-
ux-compiler
UX Framework Complier
-
scout-interpreter
A web crawling programming language
-
reic
A compiler that just works
-
clr-assembler
Modern CLR assembler for x64 and x86 instruction sets - strongly typed, object-oriented, zero-dependency core
-
zkpyc-stdlib
Standard library for the ZKPyC compiler
-
abstraps
Extensible compiler middle layer with abstract interpretation and code generation to MLIR
-
rune-modules
Native modules for Rune, an embeddable dynamic programming language for Rust
-
tlq-fhirpath
FHIRPath engine
-
voce-compiler-email
Voce IR Email compiler — compiles IR to email-safe HTML with table layouts and inline CSS
-
tishlang_cranelift
Bytecode to native via Cranelift
-
n-rustc-codegen-cranelift-pre-t-x64-win-msvc-p1
Segment rustc-codegen-cranelift-preview.target.x86_64-pc-windows-msvc part p1
-
ampc
Compiler for the Amp language
-
lib-zinc
Standard library for Zinc Programming Language
-
tenda-common
Common utilities for the Tenda programming language
-
lulz
A fast and spec-compliant LOLCODE implementation
-
riscv_analysis_cli
RISC-V static analysis tool -- CLI
-
llvm-wrapper
Safe llvm-sys wrapper
-
runtime-lexer
regex based lexer
-
yaspar-ir
few representations of SMT scripts and other functionalities
-
huam-rust-utils
这是一个用于学习rust的工具库,记录一些常用的工具函数
-
lunir
A universal intermediate representation oriented towards Lua
-
rscmm
C-interpreter
-
mutica-core
Core library for the Mutica programming language
-
charon_ariadne
A fancy diagnostics & reporting crate - resigned for crates.io/charon
-
modelx
Compiler for Modelx files
-
golang-type-name
Golang TypeName
-
logo-interp
Implements parsing and interpreting of Logo programming language
-
bfi
Print a configurable list of info about a file or directory
-
petr-utils
common utilities for the petr compiler and tooling
-
llvm-in-rust-bitcode
Compact bitcode reader and writer for LLVM-in-Rust IR modules
-
cjc-diag
Diagnostic infrastructure and error codes for CJC
-
cardinal-c
A C target for the Cardinal code generator
-
aegis-lang
A dynamic, interpreted programming language with a high-performance bytecode VM
-
moonlift
A pure-rust implementation of Lua (5.4) with just-in-time (JIT) compilation using
cranelift -
tylisp
A domain-specific language for expressing complex type bounds
-
rust-visitor
Visitor trait for Rust AST based on rust-analyzer
-
bdwgc-sys
Boehm-Demers-Weiser garbage collector bindings for Rust
-
bfcomp
A compiler for BrainF*ck implemented with AWIB and bfcore
-
airl-project
Project and workspace management for AIRL: history, queries, projections
-
quicklatex
A program to help me write LaTeX quickly
-
ylc
Ygens ir compiler
-
riscv_analysis
RISC-V static analysis tools
-
ffi_reflect_csharp
C# code generator for the
ffi_reflectpackage -
logicaffeine-lexicon
English vocabulary types and compile-time lexicon lookup for logicaffeine
-
ric-engine
Rust Interactive Console
-
swc
Speedy web compiler
-
inline-python
Inline Python code directly in your Rust code
-
quickjs-rusty
QuickJS (QuickJS-NG) Javascript engine wrapper, and more
-
qvnt-qasm
A OPENQASM 2.0 Parser
-
oak-javadoc
Javadoc documentation language parser with support for API documentation generation and code analysis
-
bork
Pretty print syntax errors for your parser or interpreter
-
quickscript
A quick programming language with a compiler implemented in Rust
-
rascal
A parser and compiler for Flash ActionScript 2 files into SWFs
-
wthr-lang
An experimental programming language for weather calculations/applications
-
gnu-libjit-sys
Rust bindings for libjit compiler
-
oak-zig
Zig language parser with support for modern Zig syntax and features
-
utigo
package manager for C++
-
koi-macros
koi programming language rust integration macros
-
tenda-prelude
Prelude for the Tenda programming language
-
kz80_bc
Arbitrary-precision decimal arithmetic language and calculator for Z80
-
artlr_lex
lexical analysis
-
zoisite
programming language designed specifically for competitive programming
-
swc_ecma_transforms_testing
rust port of babel and closure compiler
-
mesa3d
Rust API to mesa3d project (compiler, command submission)
-
petr-vm
a basic VM for running and debugging petr IR
-
synth-verify
Z3 SMT translation validation for the Synth compiler
-
mango_interpreter
The Mango programming language interpreter (UNDER CONSTRUCTION)
-
enalang_repl
Exhaustingly Notorious Algorithms - repl
-
texlang
TeX language interpreter
-
lumen-provider-fs
The AI-Native Programming Language
-
shedron
A DSL for dice rolls
-
heartfelt
Heartfelt A simple Rust library for creating DSLs (Domain Specific Languages) Roadmap This is still pretty much a work in progress. There will soon be an update with examples and documentation…
-
autoken-rustc
A rust-lang static analysis tool to automatically check for runtime borrow violations
-
wavm-cli
A 64 bit register based virtual machine
-
squirrel-sys
FFI bindings to the squirrel language
-
numbat
A statically typed programming language for scientific computations with first class support for physical dimensions and units
-
xlang
interpreter engine
-
flux-vm-v3
FLUX constraint enforcement bytecode VM — v3 architecture
-
scalyc
Compiler for the Scaly programming language
-
cedar-policy-validator
Validator for the Cedar Policy language
-
cargo-prompt
Recursively minify and concatenate source code into a markdown document for llm prompting
-
prexcl
esoteric proof-of-concept programming language
-
tenda-runtime
Runtime support for the Tenda programming language
-
yarcd
It's an mistyping use yaCRd don't use this crates if you can remove it !
-
ablescript_cli
The best programming language
-
enalang_ir
Exhaustingly Notorious Algorithms - intermediate representation definition
-
everust
Evaluates rust code
-
libjit-sys
Just-In-Time Compilation in Rust using LibJIT bindings
-
ivm-compile
The official compiler framework for ivm
-
transhader
Transpile shaders on the fly using procedural macros
-
funki_templates
A framework for creating functional domain specific languages
-
ryft-mlir
Ryft bindings for MLIR
-
metaltile-runtime
Apple Metal runtime dispatch for MetalTile GPU kernels
-
befunge-colored
A rust-powered interpreter for the befunge-colored esolang
-
portal-jsc-common
ECMAScript IR
-
pseudocode_cie_9618
pseudocode interpreter for the cie 9618 spec
-
bhc-intern
String interning for efficient symbol handling
-
safety-pass
Compiler pass infrastructure for safety-net
-
mscoree_sys_2
Bindings for the mscoree.dll symbols. Windows-only.
-
lift-config
.lith configuration language parser and validator
-
synth-core
Core types, error handling, and backend trait for the Synth compiler
-
shaqsnake_crate
My first crate
-
rune-ssa
Intermediate mode representation for Rune
-
carbon-assembler
An assembler for the carbon CPU
-
tokay
programming language designed for ad-hoc parsing
-
toy_share
Toylang development macros
-
git-voyage
Programming guide patching tool
-
mangle-driver
Driver for Mangle compilation pipeline
-
bytebeat-rs
bytebeat binary
-
oysterpack
Platform
-
oort-vm
The Oort Virtual Machine
-
cranelift
Umbrella for commonly-used cranelift crates
-
tcpp
tcpp wrappings for c/cpp preprocessor
-
mech-time
Time library for the Mech language
-
xlang-vm
A virtual machine for running Xlang programs
-
bitsy-lang
Bitsy is a modern hardware description language
-
enalang_optimizer
Exhaustingly Notorious Algorithms - optimizer
-
provekit_noirc_errors
Error reporting for the Noir compiler
-
evalexpr-jit
JIT compilation and symbolic differentiation of evalexpr expressions with Cranelift
-
kodept-ast
compiler with dependent types support in mind
-
ast_debug
Rust compiler plugin that generates relatively readable AST for inspection
-
bonk
Improved Studying
-
zirael
Compiler
-
evalit
a toy interpreter
-
synth-synthesis
WASM-to-ARM instruction selection and peephole optimizer
-
vcompiler_tools
Some useful stuff for making simple compilers
-
greengold
A Forth bytecode interpreter library
-
cala-cel-interpreter
An interpreter for the Common Expression Language (CEL)
-
psi-lang
A language for configuration and extension
-
art_documentation_demo
Just a demo from The Rust Programming Language book
-
unimarkup
CLI for the Unimarkup compiler
-
gosyn
Golang syntax parser in Rust
-
oak-bat
High-performance incremental Windows Batch (BAT) parser for the oak ecosystem with flexible configuration, supporting shell scripting and automation workflows
-
kasm
The Kerbal Compiler Collection assembler for kOS
-
swc_experimental_ecma_semantic
An extensible Rust-based platform for the next generation of fast developer tools
-
bfkit
A Brainfuck toolkit
-
fennec-parser
Fennec Programming Language
-
guile-sys
Low-level bindings to GNU Guile
-
tale_lib
A Scripting language for TTRPG Tables
-
hypersonic
Formally-verifiable distributed software
-
kz80_ml
Tiny ML compiler for the Z80 processor with Hindley-Milner type inference
-
machina
Manage and execute assembly at runtime
-
zinc-lang
Interpreter for the Zinc Programming Language
-
polyglot_interpreter
A cross-platform, cross-language interpreter of simple logical expressions
-
oak-raku
Raku (formerly Perl 6) language parser with support for advanced concurrency, grammar, and multi-paradigm programming
-
teko-rs
Command line interface for Teko
-
anyscript-compiler
A compiler for the AnyScript programming language, and Self Extracted Archives
-
brainheck
interpreter written in Rust
-
codespan
Data structures for tracking locations in source code
-
mech-system
System library for the Mech language
-
clang-preload
Sample library in rust
-
tinymist-package
Tinymist package support for Typst
-
jsompiler_lexer
Lexer for JavaScript
-
bicycle_common
Common definitions for bicycle architecture compiler crates
-
quantpiler
Сompiler of classical algorithms into oracles for quantum computing
-
dasn1-notation
A compiler for the ASN.1 notation language
-
ryft-macros
Ryft procedural macros
-
jacob
Jacob's Awesome Compiler Of BITS
-
monkey-evaluator
a evaluator for monkey lang
-
shader-slang-sys
FFI bindings for the Slang shader language compiler
-
pk_lexer
The Palacinke lang lexer
-
my_parser_some
Some description
-
qprime
An experimental programming language for quantum and weather calculations/applications
-
flycatcher
programming language
-
molt-shell
Molt Application Frameworks
-
oxc_codegen
A collection of JavaScript tools written in Rust
-
petr-pkg
package management for the petr language
-
swc_ecma_visit
Visitors for swc ecmascript nodes which works on stable rustc
-
ra_ap_rustc-dependencies
TBD
-
verilogae_util
Uilites for the rust/python glue generated by VerilogAE
-
grandiorite
hello world crate
-
seax_scheme
Scheme compiler for the Seax VM
-
qianlv_minigrep
A mini grep project for <<The Rust Programming language>>
-
llvm-bitcode
LLVM Bitcode parser in Rust
-
vcc
Valkyrie Compiler Collection
-
nvim-oxi-luajit
Rust bindings to LuaJIT for nvim-oxi
-
leo-parser-lossless
Lossless syntax tree parser for the Leo programming language
-
hclua-src
hclua
-
sus-proc-macro
Proc-macros for use in the sus-compiler
-
runmat-hir
High-level IR for RunMat with type inference and lowering utilities
-
hiko-compile
part of the hiko ML-family scripting language
-
voce-compiler-webgpu
Voce IR WebGPU compiler — compiles 3D scene IR to WebGPU render pipelines
-
intent-ir
Agent IR lowering, verification, and audit bridge for IntentLang
-
maat_vm
Stack-based virtual machine for the Maat programming language
-
tidepool
Compile Haskell effect stacks to Cranelift JIT, drive from Rust
-
hugr-cli
Compiler passes for Quantinuum's HUGR
-
stak-r7rs
Stak Scheme primitives for R7RS
-
decy-analyzer
Static analysis and type inference for C code
-
mago-collector
gathering and managing issues from various Mago tools, including support for suppression pragmas
-
haskelujah-ast
Abstract syntax tree types and helpers for the Haskelujah Haskell compiler
-
maat_bytecode
Bytecode format and serialization for the Maat virtual machine (MVM)
-
lift-ast
Lexer, parser, and AST for the .lif source language
-
depyler-verify
Property verification and formal methods for Depyler transpilation
-
ternlang-hdl
Verilog-2001 codegen for balanced ternary — BET processor primitives, sparse matmul array, FPGA simulation wrapper
-
gust-runtime
Runtime support library (traits, envelopes, supervisors) for programs compiled from Gust
-
oak-cpp
C++ systems programming language parser with support for modern C++ features and object-oriented programming
-
lex-vcs
Agent-native version control: typed op log + attestation graph
-
hiko-cli
part of the hiko ML-family scripting language
-
forked_react_compiler_lowering
Rust port of the React Compiler, vendored from react/react
-
nextjs_react_compiler
Rust port of the React Compiler, vendored from facebook/react
-
scheme4r
Scheme interpreter for rust
-
depyler-corpus
Deterministic scientific corpus analysis for Python-to-Rust transpilation quality measurement
-
wasi-assembler
Modern assembler for WASM and WASI (wit-component) - strongly typed, object-oriented, zero-dependency core
-
forgellm-codegen-gpu
GPU code generation via wgpu/WGSL for ForgeLLM
-
rustpython-jit
Experimental JIT(just in time) compiler for python code
-
tinymist-debug
Tinymist debug support for Typst
-
thinkinglanguage
CLI entry point for ThinkingLanguage (tl run, tl shell)
-
tl-compiler
Bytecode compiler and VM for ThinkingLanguage (Phase 2)
-
haskelujah-th
Template Haskell AST types, Q monad, reification, and splice evaluation for the Haskelujah compiler
-
airl-patch
Semantic patch engine for AIRL IR: apply, validate, and invert structural edits
-
oxc_span
A collection of JavaScript tools written in Rust
-
typst-library
Typst's standard library
-
stak-time
Time library for Stak Scheme
-
oak-javascript
JavaScript frontend for Oak (reuses TypeScript implementation)
-
forked_react_compiler_inference
Rust port of the React Compiler, vendored from react/react
-
typlite
Converts a subset of typst to markdown
-
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
-
steel-gen
Code generation crates for use within steel
-
lex-trace
Run-time trace tree + replay for Lex programs
-
typst-realize
Typst's realization subsystem
-
oak-python
Hand-written Python frontend
-
llvm-in-rust
Top-level facade crate for the LLVM-in-Rust compiler pipeline
-
nextjs_react_compiler_diagnostics
Rust port of the React Compiler, vendored from facebook/react
-
gust-stdlib
Standard library of reusable Gust state machines (circuit breaker, retry, saga, rate limiter, and more)
-
oak-kotlin
Kotlin language support for Oak
-
forgellm-codegen-wasm
WASM + WebGPU code generation for ForgeLLM
-
forked_react_compiler_reactive_scopes
Rust port of the React Compiler, vendored from react/react
-
decy
CLI tool for C-to-Rust transpilation with EXTREME quality standards
-
depyler
A Python-to-Rust transpiler focusing on energy-efficient, safe code generation with progressive verification
-
oak-d
High-performance incremental D language parser for the oak ecosystem with flexible configuration, supporting systems programming and native development
-
oxc_semantic
A collection of JavaScript tools written in Rust
-
oak-tcl
Tcl language parser with support for scripting, command substitution, and procedural programming features
-
oak-lean
Lean theorem prover language parser with support for dependent types and formal verification
-
stak-engine
Stak Scheme scripting engine for Rust
-
hugr-model
Data model for Quantinuum's HUGR intermediate representation