Lib.rs

rustc-demangle

Rust compiler symbol demangling

ariadne

A fancy diagnostics & reporting crate

tree-sitter

Rust bindings to the Tree-sitter parsing library

typst

A new markup-based typesetting system that is powerful and easy to learn

swc_ecma_codegen

Ecmascript code generator for the swc project

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

apollo-parser

Spec-compliant GraphQL parser

melior

The rustic MLIR bindings in Rust

oxc

A collection of JavaScript tools written in Rust

ena

Union-find, congruence closure, and other unification code. Based on code from rustc.

boa_ast

Abstract Syntax Tree definition for the Boa JavaScript engine

rustlr

Bottom-Up Parser Generator with Advanced Options

ui_test

A test framework for testing rustc diagnostics output

rustpython

A python interpreter written in rust

sus_compiler

Compiler for the SUS Hardware Design Language

rvmasm

Assembler for RvmASM

rustpython-doc

Python __doc__ database for RustPython

jaq-interpret

Interpreter for the jaq language

boa_string

Boa is a Javascript lexer, parser and compiler written in Rust. Currently, it has support for some of the language.

cel

A parser and interpreter for the Common Expression Language (CEL)

fucker

BrainFuck interpreter and optimizing JIT compiler

pluto-lang

A interpreted programming language made in Rust

gccjit

Higher-level Rust bindings for libgccjit

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.

spirt

Shader-focused IR to target, transform and translate from

cranelift-frontend

Cranelift IR builder helper

rustpython-compiler

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

c2rust

C to Rust translation, refactoring, and cross-checking

rilua

Lua 5.1.1 implemented in Rust, targeting the World of Warcraft addon variant

typst-assets

Assets for the Typst compiler

steel-core

Core compiler and VM implementation for steel

erg

programming language

clang

A somewhat idiomatic Rust wrapper for libclang

adana

namespaces aliases for command lines & basic scripting language

forgellm-cli

CLI tool for the ForgeLLM compiler

mago-syntax

A correct, fast, and memory-efficient PHP syntax implementation, including Lexer, Parser, AST, and utilities for Mago

dynasmrt

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

typespec_client_core

Client runtime for TypeSpec-generated libraries

obeli-sk-boa-parser

ECMAScript parser for the Boa JavaScript engine

ferrugocc

An experimental C compiler and obfuscating compiler written in Rust, targeting x86_64 SysV ABI

rune

Language, an embeddable dynamic programming language for Rust

cranelift-native

Support for targeting the host with Cranelift

garnish_lang_compiler

Utilites to compile garnish scripts

cranelift-jit

A JIT library backed by Cranelift

semantic-analyzer

Semantic analyzer library for compilers written in Rust for semantic analysis of programming languages AST

spirv-cross2

Safe Rust bindings to SPIRV-Cross

hstr

A string type which is optimized for hash operations

rustc-build-sysroot

Build a rustc sysroot with custom flags

ternpkg

Package manager for the ternlang ecosystem — ternlang.toml manifest, GitHub-backed registry, install/list/info commands

leo-parser-rowan

Rowan-based lossless parser for Leo

hvm

A massively parallel, optimal functional runtime in Rust

decy-parser

C AST parsing using clang-sys for Decy transpiler

frg

Compiled programming language with frogs!

ra_ap_hir

A high-level object-oriented access to Rust code for rust-analyzer

pandora-interpreter

A command-line tool to run pandora language

luars

lua 5.5 runtime implementation in Rust

cljrs-ir-prebuild

Pre-compilation tool that serialises standard library forms to IR for clojurust

airlang

Air is a minimalist and universal programming language

vrl

Vector Remap Language

lady-deirdre

Compiler front-end foundation technology. Main Crate.

kz80_lisp

A minimal LISP interpreter and compiler for RetroShield Z80

miden-objtool

Inspect Miden package MAST forest sizes

diplomat

FFI generation macro

mimium-lang

mimium(minimal-musical-medium) an infrastructural programming language for sound and music

type-sitter

generate typed wrappers for tree-sitter grammars from node-types.json and queries

rustc_version_runtime

querying the version of the rustc compiler used in runtime

cxxbridge-flags

Compiler configuration of the cxx crate (implementation detail)

ra-ap-rustc_parse_format

Automatically published version of the package rustc_parse_format in the rust-lang/rust repository from commit 68ffae46b581747074413e4242ab0c6ecc4db4a9 The publishing script for this crate lives at:…

run

a.k.a. runtool: the bridge between human and AI tooling

logicaffeine-compile

LOGOS compilation pipeline - codegen and interpreter

heraclitus-compiler

Compiler frontend for developing great programming languages

mers

dynamically typed but type-checked programming language

kansei

programming language

tishlang_compile

Tish native compiler backend

wasm-pvm

WASM to PVM (PolkaVM) recompiler

three_body_lang

Three Body Language written in Rust

rustc-std-workspace-core

integration of crates.io crates into rust-lang/rust standard library workspace

bop-lang

A small, embeddable, dynamically-typed programming language with zero dependencies

kc

Kayla's (line) counter (of code) :)

atoxide-cli

Atopile compiler CLI

nectar-lang

A compiled-to-WASM frontend language with built-in security, SEO, and mobile support

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.

gust-cli

The Gust compiler CLI — compile .gu state machine files to Rust, Go, WASM, no_std, or C FFI

chap

easy to learn, interpretive, scripting language written in Rust

xdy

Complex RPG dice expression evaluator with histogram support

haskelujah-parser

Lexer, layout, and parser pipeline for the Haskelujah compiler

from-pest

Convert from a pest grammar to a typed AST

rajac

Command-line interface for the rajac Java compiler

rumoca

Modelica compiler written in RUST

sqry-lang-groovy

Groovy language plugin for sqry

jstime

JS Runtime

clang-sys

Rust bindings for libclang

nagami

Shrinks WGSL shaders via Naga IR optimization passes

wadl

parser for Rust

lykn-cli

S-expression syntax for JavaScript — linter, formatter, and REPL

zetac

The final systems language

runmat-hir

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

typeset

A DSL for defining source code pretty printers

atc-router

Versatile DSL based rule matching engine used by the Kong API Gateway

yaspar-ir

few representations of SMT scripts and other functionalities

atlas_77

Wannabe systems programming language

vexilc

The Vexil schema compiler CLI

jsonpiler

a Json syntax programming language for Windows

phper

The framework that allows us to write PHP extensions using pure and safe Rust whenever possible

zapcode-core

A minimal, secure TypeScript subset interpreter — parse, compile, execute, snapshot

pyo3-introspection

Introspect dynamic libraries built with PyO3 to get metadata about the exported Python types

rspack_hash

rspack hash

urd

Dialogue scripting language for games — compiler, VM, and static analysis

hiko-harness

part of the hiko ML-family scripting language

stak-vm

Virtual machines for Stak Scheme

codesnake

Pretty printer for non-overlapping code spans

pliron

Programming Languages Intermediate RepresentatiON

hugr

Quantinuum's Hierarchical Unified Graph Representation

rustcc

An little C Complier( now it's just WIP :) )

airl-cli

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

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…

blisp

A lisp like statically typed programing language for no_std

maat

programming language -- Rust-native syntax for writing zero-knowledge proofs

lora-compiler

Query-plan compiler for LoraDB's Cypher implementation

swc_core

TBD

clue

C/Rust like programming language that compiles into Lua code

boa_parser

ECMAScript parser for the Boa JavaScript engine

chalk-ir

Chalk's internal representation of types, goals, and clauses

teacat

A modern document languge for web pages

node_resolver

Node.js module resolution algorithm used in Deno

tulisp

An embeddable lisp interpreter

hsml

A pug-inspired HTML preprocessor

ilo

ilo — a programming language for AI agents

lamina

High-performance compiler backend for Lamina Intermediate Representation

cargo-slicer

Speed up Rust release builds by skipping codegen for unreachable functions and processing of other skippable items

fusevm

Language-agnostic bytecode VM with fused superinstructions and Cranelift JIT path

typst-pdf

PDF exporter for Typst

bcomp

A compiler for a subset of the BASIC language

asc_bin

An automated C/C++ package manager, source code scanner, and builder that streamlines dependency management, enhances code analysis, and simplifies the build process

cudaforge

Advanced CUDA kernel builder for Rust with incremental builds, auto-detection, and external dependency support

pipeline-script

Script engine designed for the project construction tool pipeline(crate name pipeline-cli)

webfluent

The Web-First Language — compiles to HTML, CSS, JavaScript, and PDF. 50+ built-in components, reactivity, routing, i18n, SSG, and template engine.

neorusticus

A Prolog implementation in Rust with enhanced error handling

garble_lang

Turing-Incomplete Programming Language for Multi-Party Computation with Garbled Circuits

glslang

Rust bindings to glslang

mago-type-syntax

core utilities useful for building lexers and parsers within Mago

rapx

A static analysis platform for use-after-free, memory leakage detection, etc

miden-project

Interface for working with Miden projects

antimony-lang

The Antimony programming language

kz80_c

A self-hosting C compiler for Z80 targeting RetroShield hardware

somatize-compiler

Graph-to-execution-plan compiler for the Soma runtime

dust_dds_gen

OMG IDL compiler for Dust DDS

netidx-bscript

An incremental scripting language for netidx

tinymist

An integrated language service for Typst

wright

programming language compiler and tooling

generic-lang

A Lox based programming language

quickjs_runtime

Wrapper API and utils for the QuickJS JavaScript engine with support for Promise, Modules, Async/await

jexl-parser

A JEXL parser written in Rust

pasta_lua

Pasta Lua - Lua integration for Pasta DSL

tidepool-heap

Memory management and heap layout for Tidepool Core

ion-core

Embeddable scripting language with a bytecode VM

xbasic64

A BASIC-to-x86_64 native code compiler targeting 1980s-era BASIC dialects

oxc_parser

A collection of JavaScript tools written in Rust

cyclang

toy language built in LLVM

voce-schema

Voce IR schema definitions and generated FlatBuffers bindings

rune_c_compiler

A Rune to C source file 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.

a2x

A converter from ALFA to XACML policy language

faye

a pretty lil lisp

scryer-prolog

A modern Prolog implementation written mostly in Rust

starlark

language in Rust

calcit

Interpreter and js codegen for Calcit

obeli-sk-boa-ast

Abstract Syntax Tree definition for the Boa JavaScript engine

brainfoamkit

An interpreter for the brainf*** language

progenitor-middleware

An OpenAPI client generator

ai-sentinel

Compilation wrapper used to fix misc compilations bugs

oonta

OCaml (subset) to LLVM IR compiler front-end

pyimports

Parse and analyze the imports within a python package

cljrs-reader

Lexer and parser producing Form AST nodes for clojurust

ra_ap_hir_def

RPC Api for the proc-macro-srv crate of rust-analyzer

pe-assembler

PE/COFF assembler for Windows instruction sets - strongly typed, object-oriented, zero-dependency core

gluon_c-api

C-api for gluon, a static, type inferred programming language for application embedding

tishlang_bytecode

Bytecode compiler for Tish (AST → bytecode)

minipg

A modern parser generator supporting ANTLR4 grammars with code generation for Rust, Python, and JavaScript

uiua

A stack-based array programming language

csml_engine

The CSML Engine is a conversational engine designed to make it extremely easy to create rich and powerful chatbots

bicycle_random_numerics

Collect numerics for random Pauli-generated rotations run on the bicycle architecture

m68000

A Motorola 68000 interpreter, disassembler and assembler (code emitter)

Tres

Interpreter for the Tc2 esolang

cargo-abi-audit-cli

Cargo-native Rust/native ABI auditing CLI, scoped honestly to a C-ABI-first workflow

spl

Stack Pogramming Language: A simple, concise scripting language

diplomat-runtime

Common runtime utilities used by diplomat codegen

llvm-ir

LLVM IR in natural Rust data structures

nwnrs-nwscript

Neverwinter Nights NWScript resource and compiler-data helpers

netsblox-ast

parsing NetsBlox project files into an AST for use in code generation

runar-compiler-rust

Rúnar compiler (full pipeline: .runar.ts → Bitcoin Script)

spade-ast

Helper crate for https://spade-lang.org/

wesl-cli

CLI for the WESL compiler

somni-parser

Grammar parser of the Somni language and VM

lambda_mountain

Typed Macro Assembler (backed by Coq proofs-of-correctness)

grabapl

graph-based programming languages, with pluggable type systems and a focus on visible intermediate states

ascent

Logic programming in Rust

provekit_noir_debugger

Debugger for Noir

typescript

compiler and runtime

dolang-compile

Parser, resolver, and bytecode compiler for the Do language

parsanol

High-performance PEG parser library with packrat memoization and arena allocation

alef-codegen

Shared codegen utilities for the alef polyglot binding generator

cedar-policy-symcc

Symbolic Cedar Compiler (SymCC): translates queries about Cedar policies to SMT

passerine

A small extensible functional scripting language designed for concise expression with little code

slac

The "Simple Logic & Arithmetic Compiler" transforms a single expression into an abstract syntax tree

deno_webidl

WebIDL implementation for Deno

cargo-ats3

Cargo subcommand for ATS3 projects

egglang

The Egg Programming Language From Eloquent JavaScript, but in Rust

stack-graphs

Name binding for arbitrary programming languages

hi-doc

Diagnostics formatting library

kn-runtime

Dynamic wrapper around CPU and GPU inference

elworthy

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

turbofuro_worker

Worker executable for Turbofuro

swc_transform_common

Common utilities for swc transforms for any language

cloudrun-test-rust

Basic Hello world Rust for tesing Cloud Run

typespec

Project root for all TypeSpec-related crates

lumen-compiler

The AI-Native Programming Language

dolang

Embeddable public API for the Do language

metaslang_stack_graphs

Stack graphs utilities used in Slang

intent-cli

CLI toolchain for IntentLang: check, render, compile, verify, audit, query, lock, fmt, generate, init

seq-core

Core runtime library for stack-based languages (Value, Stack, Channels)

decy-hir

High-level Intermediate Representation for C-to-Rust transpilation

hiko-cli

part of the hiko ML-family scripting language

ocaml-gen

generating OCaml code

lift-cli

LIFT CLI: Command-line interface — verify, analyse, print, compile, simulate, predict

rustc_lexer

Rust lexer used by rustc. No stability guarantees are provided.

idpp

ID++ - Bahasa pemrograman berbahasa Indonesia

guryvsr

esoteric programming language gur yvsr

farmfe_compiler

Farm Compiler

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

zccache-compiler

Compiler detection and argument parsing for zccache

quantalang

compiler — an effects-oriented systems language with multi-backend codegen (C, HLSL, GLSL, SPIR-V, LLVM IR, WebAssembly, x86-64, ARM64)

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

bop-vm

Bytecode compiler and stack VM for the Bop programming language

cgrammar

A comprehensive C language grammar parser library written in Rust, implementing the C23 standard (ISO/IEC 9899:2023)

preinterpret

An intuitive toolkit to simplify code generation development

termaid-mermaid

Mermaid parsing for the Rust termaid terminal renderer

tket-qsystem

TKET tool for preparing and validating Hugrs for compilation targeting Quantinuum H-series quantum computers

cc2600

a subset of C compiler for Atari 2600

bend-lang

A high-level, massively parallel programming language

soppo

Compiler for Soppo, a Go superset with enums, pattern matching, and nil safety

type-bridge-core-lib

TypeQL AST, schema parser, query compiler, and validation engine for type-bridge

strykelang

A highly parallel Perl 5 interpreter written in Rust

lmntalc

A compiler for the LMNtal language

danwi

SI units library

r2u2_cli

R2U2 CLI: A stream-based runtime monitor command-line interface

sixtyfive

An interpreter for the Sixtyfive programming language, designed for teaching computer science to moths

morok-codegen

Backend code generation for the Morok ML compiler

marigold

Programming Language

monkey-parser

a parser for monkey lang

polonius-engine

Core definition for the Rust borrow checker

verter_core

Vue 3 SFC compiler - transforms Vue Single File Components to render functions with TypeScript support

dlwrap

dlopen wrapper code generator

nashc

Compiler for the nash programming language

zia

Interpreter Library for the Zia Programming Language

galvan

A higher-level programming language that transpiles to Rust

leo-abi

ABI generation for Leo programs

midenup

The Miden toolchain manager

windy-lang

Windy — a 2D esoteric programming language where code flows like wind

bund

Interpreter and CLI for a Virtual Machine for BUND programming language

rustc_utils

working with the Rust compiler

mech-set

Set library for the Mech language

phenotyper

Core compiler library for the Phenotyper structural artifact definition language

tishlang_parser

Tish recursive descent parser

plotnik-compiler

Compiler for Plotnik query language (parser, analyzer, bytecode emitter)

liteml

一个用 Rust 实现的轻量级标记语言编译器。

olotin1

procss

CSS parsing and transformation framework

tket-json-rs

Serializable definition of TKET circuits and operations

vegen

A compiler for tiny, efficient, updatable TypeScript HTML templates

leo-disassembler

A disassembler for the Leo programming language

lisp-rs

Lisp interpreter in Rust

metrowrap

A mwcc wrapper

irvm

A IR compiler target with a Rust friendly API that lowers to LLVM IR

quickjspp

QuickJS Javascript engine wrapper using quickjs fork named quickjspp

surreal-lang

A Rust-inspired language for the BEAM

scopegraphs

A well-documented port of scopegraphs to Rust

cargo_info_types

Parse the output of cargo info into well-typed Rust structures

chapter3_lexical

A lexical analyzer that returns the tokens you wrote!

dlexer

A high-performance, functional parser combinator library for Rust

cargo_pup_lint_impl

Core lint implementations and rustc integration for cargo-pup architectural linting

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.

ghci

Manage and communicate with ghci (Haskell's GHC interpreter)

cortex-lang

interpreted language for interfacing with Rust code

vize_relief

Relief - The sculptured AST surface for Vize Vue templates

parlex

Core support library for parsers and lexers generated by parlex-gen

mutica

programming language

purua

PU-RU-A is a PUre RUst luA implementation (to be)

mystsh

Mystical shell parser, formatter, and interpreter with Bash support

single-variable-algebra-compiler

A compiler for the minimalistic programming language single-variable-algebra

x86_64-assembler

Modern assembler for x64 and x86 instruction sets - strongly typed, object-oriented, zero-dependency core

lib-ruby-parser-nodes

Ruby parser nodes data

java_asm

Java bytecode reader & writer in rust

adana-cache-command

namespaces aliases for command lines & basic scripting language

mech

programming language for building reactive systems like robots, games, and animations

amethyst_geode

Turing Machine Programming Language Interpreter

awa5_rs

An AWA5.0 CLI tool written in Rust (btw)

cambridge-asm

Run pseudoassembly from Cambridge International syllabus 9618

oak-typescript

TypeScript frontend for Oak

hilang

A small programming language

garden-lang

A live programming language

rspack_error

rspack error

mmi-cli

CLI and compiler for Mastermind, the BF compiler

synoema-parser

Synoema — programming language optimized for LLM code generation

ra-ap-rustc_next_trait_solver

Automatically published version of the package rustc_next_trait_solver in the rust-lang/rust repository from commit ec2d669db8e5ca2cb1604c69a831ef244ebd9aa9 The publishing script for this crate lives at:…

forgellm-frontend

Model parsing (GGUF, SafeTensors) and IR construction for ForgeLLM

obeli-sk-boa-engine

Boa is a Javascript lexer, parser and compiler written in Rust. Currently, it has support for some of the language.

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.

splik

programming language identifier kit

microcad-syntax

µcad syntax lexer and parser

sevenmark_parser

Core parsing engine for SevenMark wiki markup

ra-ap-rustc_abi

Automatically published version of the package rustc_abi in the rust-lang/rust repository from commit ec2d669db8e5ca2cb1604c69a831ef244ebd9aa9 The publishing script for this crate lives at:…

wasc

A C-like language compiler for WebAssembly with first-class support for references and tables

simpleton

runner for Intuicio scripting platform

stak-device

Devices for Stak Scheme

rsjsonnet-lang

A Jsonnet evaluation library

llvm-pm

Safe Rust wrapper for LLVM new PassManager

typst-batch

Typst helper library for batch processing — friendly API, shared resources, virtual files, customizable diagnostics

vyre

GPU compute intermediate representation with a standard operation library

edlc_lsp

EDLc Language Sever Protocol implementation

aplang

A programming language made to aid students who are taking AP Computer Science Principals

axon-frontend

AXON compiler frontend — lexer, parser, AST, epistemic type system, type checker, IR generator, compile-time checker. Zero runtime dependencies (no tokio/axum/sqlx/reqwest); consumable…

slasherc

A programming language for school, built in Rust

diffsl

A compiler for a domain-specific language for ordinary differential equations (ODE)

tremor-script

Tremor Script Interpreter

haskelujah-ast

Abstract syntax tree types and helpers for the Haskelujah Haskell compiler

kind2

A pure functional functional language that uses the HVM

hmacro

macro preprocessor

viper-py

A fast Python interpreter written in Rust

endbasic

programming language - CLI

maid-lang

Maid Programming Language

cljrs-eval

IR-accelerated evaluation for clojurust (tier-1 IR interpreter + lowering)

ternlang-hdl

Verilog-2001 codegen for balanced ternary — BET processor primitives, sparse matmul array, FPGA simulation wrapper

mago-span

Tracks exact character positions in source code, making it easier to report precise errors, warnings, and other diagnostics

csw-cli

Command-line interface for the Categorical Semantics Workbench

flowistry

Modular information flow analysis

grepdef

Quick search for symbol definitions in various programming languages

rustc-ap-rustc_lexer

Automatically published version of the package rustc_lexer in the rust-lang/rust repository from commit 9a27044f42ace9eb652781b53f598e25d4e7e918 The publishing script for this crate lives at: https://github…

tex_engine

A modular crate for building TeX engines

cranelift-codegen

Low-level code generator library

infr

A gradually typed superset of R

morok-runtime

Kernel execution runtime for the Morok ML compiler

corvo7

A toy programming language compiler written in Rust

ascent-interpreter

Interpreter and JIT for Ascent Datalog programs

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

uxn-tal

uxntal:// protocol | a Rust library for assembling TAL (Tal Assembly Language) files into UXN ROM files

grammatica

representing and transforming formal grammars (Chomsky hierarchy today; extensible toward attribute, probabilistic, and specialized grammars)

ilm

A fun programming language with Islamic terminology

draxl

Agent-native source for semantic program control

janetrs

High level binding for Janet programming language

cljrs-ir

Intermediate representation types for clojurust compiler and interpreter

rust_lisp

A Rust-embeddable Lisp, with support for interop with native Rust functions

hclua

bbnf-ir

Canonical Grammar IR for the BBNF compiler pipeline

provekit_noirc_evaluator

Evaluator for the Noir compiler SSA pipeline

python-rs

A stackless Python 3 interpreter written in Rust — NaN-boxed values, zero dependencies

pascal

A modern Pascal compiler with build/intepreter/package manager built with Rust

mogi_sleigh_parser

Parser for Sleigh specifications

qbe

QBE IR for Rust

spade-lang

The Spade compiler

fta

Fast TypeScript Analyzer

astmap-languages

Language parsers and resolvers for astmap (tree-sitter based)

temporaries

Make temporary values useable in a fairly normal style through macros. This nicely wraps the hacks that work around temporaries’ earlier limitations.

sqry-lang-scala

Scala language plugin for sqry

libwild

that provides a fast Linux linker

prune-lang

Prune is a constraint logic programming language with branching heuristic

virtual-rust

A virtual machine that interprets and runs Rust source code directly without compilation

lsts

Large Scale Type Systems

gluon

A static, type inferred programming language for application embedding

oak-dhall

Dhall language parser with support for functional programming and type system features

tidepool-repr

Intermediate representation for the Tidepool compiler

archscript

programming language — Python-like syntax, Haskell-inspired features, Arch Linux integration

typst-svg

SVG exporter for Typst

analisar

A Lua parser for Rust

lustc

A Lean4 subset to Rust source-to-source compiler

vexil-lang

Compiler library for the Vexil schema definition language — lexer, parser, IR, and type checker

rowl

Parser for the Dolfin Ontology 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

lex

aids in parsing programming languages

vize_atelier_core

Atelier Core - The core workshop for Vize Vue template parsing and transforms