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

jaq-interpret

Interpreter for the jaq language

rvmasm

Assembler for RvmASM

rustpython-doc

Python __doc__ database for RustPython

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

cranelift-frontend

Cranelift IR builder helper

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.

c2rust

C to Rust translation, refactoring, and cross-checking

ferrugocc

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

rilua

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

steel-core

Core compiler and VM implementation for steel

erg

programming language

clang

A somewhat idiomatic Rust wrapper for libclang

typst-assets

Assets for the Typst compiler

adana

namespaces aliases for command lines & basic scripting language

spirt

Shader-focused IR to target, transform and translate from

forgellm-cli

CLI tool for the ForgeLLM compiler

ra_ap_hir

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

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.

obeli-sk-boa-ast

Abstract Syntax Tree definition for the Boa JavaScript engine

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

harn-parser

Parser, AST, and type checker for the Harn programming language

spirv-cross2

Safe Rust bindings to SPIRV-Cross

typespec_client_core

Client runtime for TypeSpec-generated libraries

semantic-analyzer

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

hstr

A string type which is optimized for hash operations

rustc-build-sysroot

Build a rustc sysroot with custom flags

hvm

A massively parallel, optimal functional runtime in Rust

frg

Compiled programming language with frogs!

decy-hir

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

kz80_lisp

A minimal LISP interpreter and compiler for RetroShield Z80

lady-deirdre

Compiler front-end foundation technology. Main Crate.

pandora-interpreter

A command-line tool to run pandora language

chap

easy to learn, interpretive, scripting language written in Rust

ra-ap-rustc_lexer

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

leo-parser-rowan

Rowan-based lossless parser for Leo

airlang

Air is a minimalist and universal programming language

nagami

Shrinks WGSL shaders via Naga IR optimization passes

vrl

Vector Remap Language

luars

lua 5.5 runtime implementation in Rust

cranelift-jit

A JIT library backed by Cranelift

ternpkg

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

miden-objtool

Inspect Miden package MAST forest sizes

diplomat

FFI generation macro

sqry-lang-groovy

Groovy language plugin for sqry

rustc_version_runtime

querying the version of the rustc compiler used in runtime

cxxbridge-flags

Compiler configuration of the cxx crate (implementation detail)

run

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

heraclitus-compiler

Compiler frontend for developing great programming languages

mers

dynamically typed but type-checked programming language

three_body_lang

Three Body Language written in Rust

kansei

programming language

tishlang_compile

Tish native compiler backend

yaspar-ir

few representations of SMT scripts and other functionalities

rumoca

Modelica compiler written in RUST

logicaffeine-compile

LOGOS compilation pipeline - codegen and interpreter

wasm-pvm

WASM to PVM (PolkaVM) recompiler

atoxide-cli

Atopile compiler CLI

rustc-std-workspace-core

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

kc

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

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.

xdy

Complex RPG dice expression evaluator with histogram support

type-sitter

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

python-ast

compiling Python to Rust

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

jstime

JS Runtime

clang-sys

Rust bindings for libclang

wadl

parser for Rust

lykn-cli

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

zetac

The final systems language

typeset

A DSL for defining source code pretty printers

atc-router

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

atlas_77

Wannabe systems programming language

jsonpiler

a Json syntax programming language for Windows

rapx

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

phper

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

codesnake

Pretty printer for non-overlapping code spans

clue

C/Rust like programming language that compiles into Lua code

rspack_hash

rspack hash

zapcode-core

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

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

pliron

Programming Languages Intermediate RepresentatiON

intent-cli

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

vexilc

The Vexil schema compiler CLI

maat

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

swc_core

TBD

chalk-ir

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

boa_parser

ECMAScript parser for the Boa JavaScript engine

rustcc

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

hugr

Quantinuum's Hierarchical Unified Graph Representation

hsml

A pug-inspired HTML preprocessor

typst-pdf

PDF exporter for Typst

node_resolver

Node.js module resolution algorithm used in Deno

ilo

ilo — a programming language for AI agents

lamina

High-performance compiler backend for Lamina Intermediate Representation

pipeline-script

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

antimony-lang

The Antimony programming 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

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

rexlang-engine

Rex: A strongly-typed, pure, implicitly parallel functional programming language

blisp

A lisp like statically typed programing language for no_std

garble_lang

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

cargo-ats3

Cargo subcommand for ATS3 projects

cargo-slicer

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

cyclang

toy language built in LLVM

bend-lang

A high-level, massively parallel programming language

glslang

Rust bindings to glslang

mimium-lang

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

miden-project

Interface for working with Miden projects

runar-compiler-rust

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

kz80_c

A self-hosting C compiler for Z80 targeting RetroShield hardware

jexl-parser

A JEXL parser written in Rust

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

obeli-sk-boa-parser

ECMAScript parser for the Boa JavaScript engine

somatize-compiler

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

quickjs_runtime

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

mago-type-syntax

core utilities useful for building lexers and parsers within Mago

pasta_lua

Pasta Lua - Lua integration for Pasta DSL

brainfoamkit

An interpreter for the brainf*** language

tidepool-heap

Memory management and heap layout for Tidepool Core

xbasic64

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

oxc_parser

A collection of JavaScript tools written in Rust

typescript

compiler and runtime

voce-schema

Voce IR schema definitions and generated FlatBuffers bindings

lift-cli

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

llvm-ir

LLVM IR in natural Rust data structures

rune_c_compiler

A Rune to C source file compiler

tishlang_parser

Tish recursive descent parser

dolang-compile

Parser, resolver, and bytecode compiler for the Do language

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

ra-ap-rustc_parse_format

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

scryer-prolog

A modern Prolog implementation written mostly in Rust

teacat

A modern document languge for web pages

starlark

language in Rust

cranelift-codegen

Low-level code generator library

spl

Stack Pogramming Language: A simple, concise scripting language

progenitor-middleware

An OpenAPI client generator

m68000

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

ai-sentinel

Compilation wrapper used to fix misc compilations bugs

calcit

Interpreter and js codegen for Calcit

oonta

OCaml (subset) to LLVM IR compiler front-end

bop-cli

CLI and REPL for the Bop programming language

pyimports

Parse and analyze the imports within a python package

minipg

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

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

grabapl

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

diplomat-runtime

Common runtime utilities used by diplomat codegen

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

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

bicycle_random_numerics

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

ion-core

Embeddable scripting language with a bytecode VM

netsblox-ast

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

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)

ascent

Logic programming in Rust

plotnik-compiler

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

deno_webidl

WebIDL implementation for Deno

parsanol

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

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

egglang

The Egg Programming Language From Eloquent JavaScript, but in Rust

stack-graphs

Name binding for arbitrary programming languages

dlexer

A high-performance, functional parser combinator library for Rust

hi-doc

Diagnostics formatting library

llts

TypeScript to native compiler via LLVM

spade-ast

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

ra_ap_hir_def

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

kn-runtime

Dynamic wrapper around CPU and GPU inference

swc_transform_common

Common utilities for swc transforms for any language

turbofuro_worker

Worker executable for Turbofuro

cloudrun-test-rust

Basic Hello world Rust for tesing Cloud Run

provekit_noir_debugger

Debugger for Noir

cedar-policy-symcc

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

typespec

Project root for all TypeSpec-related crates

dolang

Embeddable public API for the Do language

metaslang_stack_graphs

Stack graphs utilities used in Slang

cljrs-reader

Lexer and parser producing Form AST nodes for clojurust

hiko-cli

part of the hiko ML-family scripting language

ocaml-gen

generating OCaml code

mini-c-parser

minimal C language lexer & parser & virtual executer from scratch

preinterpret

An intuitive toolkit to simplify code generation development

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

quantalang

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

seq-core

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

rustc_lexer

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

nashc

Compiler for the nash programming language

lust-rs

A WIP Lua-like scripting language implemented in Rust, designed for embedding and rapid scripting with a strong type system, with trace-based JIT

cgrammar

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

lex

aids in parsing programming languages

termaid-mermaid

Mermaid parsing for the Rust termaid terminal renderer

lite_ml

Lightweight markup language compiler

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

surreal-lang

A Rust-inspired language for the BEAM

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

guryvsr

esoteric programming language gur yvsr

tishlang_bytecode

Bytecode compiler for Tish (AST → bytecode)

strykelang

A highly parallel Perl 5 interpreter written in Rust

polonius-engine

Core definition for the Rust borrow checker

lmntalc

A compiler for the LMNtal language

mux-lang

The Mux Programming Language Compiler

java_asm

Java bytecode reader & writer in rust

r2u2_cli

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

oak-typescript

TypeScript frontend for Oak

sixtyfive

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

lisp-rs

Lisp interpreter in Rust

marigold

Programming Language

monkey-parser

a parser for monkey lang

vize_relief

Relief - The sculptured AST surface for Vize Vue templates

zccache-compiler

Compiler detection and argument parsing for zccache

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

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.

midenup

The Miden toolchain manager

bund

Interpreter and CLI for a Virtual Machine for BUND programming language

lumen-vm

The AI-Native Programming Language

rustc_utils

working with the Rust compiler

mech-set

Set library for the Mech language

synoema-types

Synoema — programming language optimized for LLM code generation

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

danwi

SI units library

leo-disassembler

A disassembler for the Leo programming language

metrowrap

A mwcc wrapper

quickjspp

QuickJS Javascript engine wrapper using quickjs fork named quickjspp

vyre

GPU compute intermediate representation with a standard operation library

qbe

QBE IR for Rust

cargo_info_types

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

lib-ruby-parser-nodes

Ruby parser nodes data

chapter3_lexical

A lexical analyzer that returns the tokens you wrote!

cargo_pup_lint_impl

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

cortex-lang

interpreted language for interfacing with Rust code

x86_64-assembler

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

mutica

programming language

elworthy

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

purua

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

mystsh

Mystical shell parser, formatter, and interpreter with Bash support

fusabi-frontend

Frontend (parser, compiler) for Fusabi language

hilang

A small programming language

single-variable-algebra-compiler

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

adana-cache-command

namespaces aliases for command lines & basic scripting language

sqry-classpath

JVM classpath analysis for sqry - bytecode parsing, build system resolution, and graph integration

mech

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

amethyst_geode

Turing Machine Programming Language Interpreter

irvm

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

scopegraphs

A well-documented port of scopegraphs to Rust

awa5_rs

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

cambridge-asm

Run pseudoassembly from Cambridge International syllabus 9618

gabelang

A high level, interpretted and garbage collected programming language

infr

A gradually typed superset of R

garden-lang

A live programming language

rspack_error

rspack error

viper-py

A fast Python interpreter written in Rust

ra-ap-rustc_next_trait_solver

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

decy-ownership

Ownership and lifetime inference for C-to-Rust conversion (CRITICAL)

forgellm-frontend

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

python-rs

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

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.

lexigram

Lexer and LL(1) parser generator

splik

programming language identifier kit

sevenmark_parser

Core parsing engine for SevenMark wiki markup

lexit

A Lexical Analysis tool for defining a language and lexing it into tokens

virtual-rust

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

ghci

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

simpleton

runner for Intuicio scripting platform

specl-syntax

Lexer, parser, and AST for the Specl specification language

stak-device

Devices for Stak Scheme

rsjsonnet-lang

A Jsonnet evaluation library

obeli-sk-boa-engine

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

ilm

A fun programming language with Islamic terminology

mblf

The MBLF-To-BF compiler written in Rust with Pest. MBLF is a programming language on top of the esoteric programming language Brainfuck

sema-reader

Lexer and s-expression parser for the Sema programming language

gluon

A static, type inferred programming language for application embedding

typst-batch

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

edlc_lsp

EDLc Language Sever Protocol implementation

aplang

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

rustpython-codegen

Compiler for python code into bytecode for the rustpython VM

slasherc

A programming language for school, built in Rust

tremor-script

Tremor Script Interpreter

haskelujah-ast

Abstract syntax tree types and helpers for the Haskelujah Haskell compiler

diffsl

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

liteml

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

phenotyper

Core compiler library for the Phenotyper structural artifact definition language

kind2

A pure functional functional language that uses the HVM

prune-lang

Prune is a constraint logic programming language with branching heuristic

hmacro

macro preprocessor

cljrs-ir

Intermediate representation types for clojurust compiler and interpreter

wasc

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

microcad-syntax

µcad syntax lexer and parser

endbasic

programming language - CLI

maid-lang

Maid Programming Language

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

tex_engine

A modular crate for building TeX engines

pepl-compiler

PEPL compiler: orchestrates the full compilation pipeline

mago-span

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

astmap-languages

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

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

fta

Fast TypeScript Analyzer

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

floe

A programming language that compiles to TypeScript + React

abyss-lang

AbySS: Advanced-scripting by Symbolic Syntax

vize_carton

Carton - The artist's toolbox for Vize compiler

grammatica

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

draxl

Agent-native source for semantic program control

janetrs

High level binding for Janet programming language

jzero-semantic

Semantic analysis and type checking for the Jzero compiler

alef-codegen

Shared codegen utilities for the alef polyglot binding generator

rust_lisp

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

horkos

Cloud infrastructure language where insecure code won't compile

hclua

bbnf-ir

Canonical Grammar IR for the BBNF compiler pipeline

provekit_noirc_evaluator

Evaluator for the Noir compiler SSA pipeline

vbscript

lexer and parser

lustc

A Lean4 subset to Rust source-to-source compiler

pascal

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

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…

spade-lang

The Spade compiler

temporaries

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

libwild

that provides a fast Linux linker

umjunsik

Language compiler targeting Lamina IR

lsts

Large Scale Type Systems

mmi-cli

CLI and compiler for Mastermind, the BF compiler

swc_emotion

AST Transforms for emotion

tidepool-repr

Intermediate representation for the Tidepool compiler

archscript

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

som

The 'som' programming language

mogi_sleigh_parser

Parser for Sleigh specifications

analisar

A Lua parser for Rust

dcim

dc improved - Expanded rewrite of a classic RPN calculator / esoteric programming language

harn-modules

Cross-file module graph and import resolution utilities for Harn

piccolo

Stackless Lua VM implemented in pure Rust