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

boa_engine

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

llvm-sys

Bindings to LLVM's C API

rquickjs

High level bindings to the QuickJS JavaScript engine

apollo-parser

Spec-compliant GraphQL parser

swc_ecma_codegen

Ecmascript code generator for the swc project

ena

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

oxc

A collection of JavaScript tools written in Rust

melior

The rustic MLIR bindings in Rust

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

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.

sus_compiler

Compiler for the SUS Hardware Design Language

rvmasm

Assembler for RvmASM

winch-codegen

Winch code generation library

fucker

BrainFuck interpreter and optimizing JIT compiler

pluto-lang

A interpreted programming language made in Rust

cel

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

adana

namespaces aliases for command lines & basic scripting language

rilua

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

boa_string

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

gccjit

Higher-level Rust bindings for libgccjit

c2rust

C to Rust translation, refactoring, and cross-checking

erg

programming language

spirt

Shader-focused IR to target, transform and translate from

typst-assets

Assets for the Typst compiler

cranelift-frontend

Cranelift IR builder helper

mago-syntax

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

rune

Language, an embeddable dynamic programming language for Rust

dynasmrt

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

jaq-interpret

Interpreter for the jaq language

vrl

Vector Remap Language

jstime

JS Runtime

kc

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

hvm

A massively parallel, optimal functional runtime in Rust

lady-deirdre

Compiler front-end foundation technology. Main Crate.

clang

A somewhat idiomatic Rust wrapper for libclang

garnish_lang_compiler

Utilites to compile garnish scripts

thot

An asm

kz80_lisp

A minimal LISP interpreter and compiler for RetroShield Z80

atoxide-cli

Atopile compiler CLI

pandora-interpreter

A command-line tool to run pandora language

spirv-cross2

Safe Rust bindings to SPIRV-Cross

ra_ap_hir

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

rustc_version_runtime

querying the version of the rustc compiler used in runtime

semantic-analyzer

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

typespec_client_core

Client runtime for TypeSpec-generated libraries

parsanol

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

three_body_lang

Three Body Language written in Rust

rspack_hash

rspack hash

ra-ap-rustc_lexer

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

wasm-pvm

WASM to PVM (PolkaVM) recompiler

boa_parser

ECMAScript parser for the Boa JavaScript engine

cranelift-native

Support for targeting the host with Cranelift

rumoca

Modelica compiler written in RUST

clue

C/Rust like programming language that compiles into Lua code

lambda_mountain

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

from-pest

Convert from a pest grammar to a typed AST

mers

dynamically typed but type-checked programming language

kansei

programming language

logicaffeine-compile

LOGOS compilation pipeline - codegen and interpreter

rustpython-vm

RustPython virtual machine

airlang

Air is a minimalist and universal programming language

onion-lang

A modern functional programming language with asynchronous execution and lazy evaluation

blisp

A lisp like statically typed programing language for no_std

ilo

ilo — a programming language for AI agents

diplomat

FFI generation macro

type-sitter

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

atc-router

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

chap

easy to learn, interpretive, scripting language written in Rust

python-ast

compiling Python to Rust

run

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

depyler-annotations

Annotation parsing and processing for Depyler

typeset

A DSL for defining source code pretty printers

rustc-build-sysroot

Build a rustc sysroot with custom flags

lustc

A Lean4 subset to Rust source-to-source compiler

phper

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

hugr

Quantinuum's Hierarchical Unified Graph Representation

rapx

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

heraclitus-compiler

Compiler frontend for developing great programming languages

stak-vm

Virtual machines for Stak Scheme

rustpython-ast

AST definitions for RustPython

intent-cli

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

antimony-lang

The Antimony programming language

node_resolver

Node.js module resolution algorithm used in Deno

packtab

Pack static integer tables into compact multi-level lookup tables

sema-lang

Sema — a Lisp dialect with first-class LLM primitives

jsonpiler

a Json syntax programming language for Windows

pyo3-introspection

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

runmat-hir

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

netsblox-ast

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

rustcc

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

llvm-ir

LLVM IR in natural Rust data structures

garble_lang

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

pliron

Programming Languages Intermediate RepresentatiON

midenc-log

flexible trace logging for midenc

lamina

High-performance compiler backend for Lamina Intermediate Representation

clang-sys

Rust bindings for libclang

zapcode-core

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

xbasic64

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

java_asm

Java bytecode reader & writer in rust

chalk-ir

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

swc_core

TBD

cargo-slicer

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

typst-pdf

PDF exporter for Typst

generic-lang

A Lox based programming language

pipeline-script

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

mimium-lang

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

bop-cli

CLI and REPL for the Bop 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

llts

TypeScript to native compiler via LLVM

pixelscript

Multi language scripting runtime

wright

programming language compiler and tooling

python-rs

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

neorusticus

A Prolog implementation in Rust with enhanced error handling

scryer-prolog

A modern Prolog implementation written mostly in Rust

mago-reporting

Structured error and diagnostic reporting utilities

cargo-ats3

Cargo subcommand for ATS3 projects

cyclang

toy language built in LLVM

cargo-abi-audit-cli

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

swc_ecma_transforms_typescript

rust port of babel and closure compiler

forge-lang

Forge — Internet-native programming language with natural syntax, bytecode VM, and built-in HTTP/database/crypto

bend-lang

A high-level, massively parallel programming language

kz80_c

A self-hosting C compiler for Z80 targeting RetroShield hardware

cxxbridge-flags

Compiler configuration of the cxx crate (implementation detail)

glslang

Rust bindings to glslang

rspack_plugin_css

rspack css plugin

plotnik-compiler

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

cudaforge

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

zetac

The final systems language

brainfoamkit

An interpreter for the brainf*** language

lumen-compiler

The AI-Native Programming Language

sqry-lang-java

Java language plugin for sqry

atlas_77

Wannabe systems programming language on a custom VM (for now)

pasta_lua

Pasta Lua - Lua integration for Pasta DSL

rune_c_compiler

A Rune to C source file compiler

mech

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

progenitor-middleware

An OpenAPI client generator

quickjs_runtime

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

tidepool-heap

Memory management and heap layout for Tidepool Core

spl

Stack Pogramming Language: A simple, concise scripting language

dust_dds_gen

OMG IDL compiler for Dust DDS

wadl

parser for Rust

a2x

A converter from ALFA to XACML policy language

cloudrun-test-rust

Basic Hello world Rust for tesing Cloud Run

fta

Fast TypeScript Analyzer

faye

a pretty lil lisp

draxl-ast

Typed AST and metadata model for Draxl

type-bridge-core-lib

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

leo-interpreter

Interpreter for the Leo programming language

oxc_parser

A collection of JavaScript tools written in Rust

pyimports

Parse and analyze the imports within a python package

m68000

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

runmat-ignition

Baseline interpreter for RunMat enabling instant startup and execution

turbofuro_worker

Worker executable for Turbofuro

gluon_c-api

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

ascent

Logic programming in Rust

guryvsr

esoteric programming language gur yvsr

somni-expr

An expression evaluation library

csml_engine

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

tinymist-assets

assets for tinymist

starlark

language in Rust

grabapl

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

ocaml-gen

generating OCaml code

calcit

Interpreter and js codegen for Calcit

minipg

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

sixtyfive

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

wesl-cli

CLI for the WESL compiler

ra-ap-rustc_parse_format

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

spade-ast

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

virtual-rust

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

runar-compiler-rust

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

hi-doc

Diagnostics formatting library

thinkinglanguage

CLI entry point for ThinkingLanguage (tl run, tl shell)

slac

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

jexl-parser

A JEXL parser written in Rust

mux-lang

The Mux Programming Language Compiler

steel-core

Core compiler and VM implementation for steel

egglang

The Egg Programming Language From Eloquent JavaScript, but in Rust

passerine

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

diplomat-runtime

Common runtime utilities used by diplomat codegen

dlexer

A high-performance, functional parser combinator library for Rust

pe-assembler

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

cranelift-jit

A JIT library backed by Cranelift

mini-c-parser

minimal C language lexer & parser & virtual executer from scratch

cc2600

a subset of C compiler for Atari 2600

ra_ap_hir_def

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

bashrs

Rust-to-Shell transpiler for deterministic bootstrap scripts

tket

Quantinuum's TKET Quantum Compiler

seq-core

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

vbscript

lexer and parser

kind2

A pure functional functional language that uses the HVM

deno_webidl

WebIDL implementation for Deno

chapter3_lexical

A lexical analyzer that returns the tokens you wrote!

aver-lang

Interpreter and transpiler for Aver, a statically-typed language designed for AI-assisted development

camel-dsl

DSL support for rust-camel (YAML, etc)

typespec

Project root for all TypeSpec-related crates

libwild

that provides a fast Linux linker

qbe

QBE IR for Rust

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

nashc

Compiler for the nash programming language

surreal-lang

A Rust-inspired language for the BEAM

oonta

OCaml (subset) to LLVM IR compiler front-end

pen-ffi

FFI library for Pen programming language

soppo

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

preinterpret

An intuitive toolkit to simplify code generation development

fastc-lsp

Language Server Protocol implementation for FastC

vegen

A compiler for tiny, efficient, updatable TypeScript HTML templates

tket-json-rs

Serializable definition of TKET circuits and operations

uiua

A stack-based array programming language

wasc

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

edlc_lsp

EDLc Language Sever Protocol implementation

lisp-rs

Lisp interpreter in Rust

bund

Interpreter and CLI for a Virtual Machine for BUND programming language

cortex-lang

interpreted language for interfacing with Rust code

scopegraphs

A well-documented port of scopegraphs to Rust

rustc_lexer

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

r2u2_cli

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

cgrammar

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

vize_relief

Relief - The sculptured AST surface for Vize Vue templates

procss

CSS parsing and transformation framework

hmacro

macro preprocessor

olotin1

splik

programming language identifier kit

monkey-parser

a parser for monkey lang

mystsh

Mystical shell parser, formatter, and interpreter with Bash support

shape-jit

Tiered JIT compiler (Cranelift) for the Shape virtual machine

zia

Interpreter Library for the Zia Programming Language

galvan

A higher-level programming language that transpiles to Rust

qvcm

Register-based bytecode VM with quantum computing functionality

polonius-engine

Core definition for the Rust borrow checker

sevenmark_parser

Core parsing engine for SevenMark wiki markup

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

purua

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

koopa

generating/parsing/optimizing Koopa IR

tupa-codegen

Code generation layer for TupaLang

xdy

Complex RPG dice expression evaluator with histogram support

lucia-lasm

LASM - Lucia Assembly Language

verter_core

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

amethyst_geode

Turing Machine Programming Language Interpreter

danwi

SI units library

endbasic

programming language - CLI

leo-abi

ABI generation for Leo programs

gabelang

A high level, interpretted and garbage collected programming language

mech-set

Set library for the Mech language

corvo7

A toy programming language compiler written in Rust

stck

An embeddable interpreted language written fully in rust

irvm

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

lib-ruby-parser-nodes

Ruby parser nodes data

awa5_rs

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

lexit

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

tinymist

An integrated language service for Typst

mblf

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

fusabi-frontend

Frontend (parser, compiler) for Fusabi language

hilang

A small programming language

csw-cli

Command-line interface for the Categorical Semantics Workbench

single-variable-algebra-compiler

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

codemem-index

Tree-sitter code indexing for Codemem memory engine

ilm

A fun programming language with Islamic terminology

windjammer

language inspired by Go, Ruby, and Elixir that transpiles to Rust - 80% of Rust's power with 20% of the complexity

adana-cache-command

namespaces aliases for command lines & basic scripting language

umjunsik

Language compiler targeting Lamina IR

metaslang_stack_graphs

Stack graphs utilities used in Slang

pascal

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

somni-parser

Grammar parser of the Somni language and VM

garden-lang

A live programming language

codanna

Code Intelligence for Large Language Models

asg-lang

ASG - A programming language built on Abstract Syntax Graph

x86_64-assembler

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

fift-cli

A CLI for the Fift esoteric language interpreter

rust_lisp

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

simpleton

runner for Intuicio scripting platform

mago-names

Resolves and normalizes identifiers (classes, functions, constants) within PHP code

specl-syntax

Lexer, parser, and AST for the Specl specification language

stak-device

Devices for Stak Scheme

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

hclua

rustc_utils

working with the Rust compiler

littrs-ruff-python-parser

Vendored ruff_python_parser for littrs (from github.com/astral-sh/ruff)

aplang

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

horkos

Cloud infrastructure language where insecure code won't compile

flowistry

Modular information flow analysis

resrap-rs

A rule based code generator

tremor-script

Tremor Script Interpreter

plotnik-vm

Runtime VM for executing compiled Plotnik queries

maid-lang

Maid Programming Language

bhc-ast

Abstract syntax tree definitions for BHC

rma-parser

Tree-sitter based polyglot parser for Qryon

rdx-transform

Transform pipeline and built-in plugins for RDX (Reactive Document eXpressions) ASTs

haloumi-ir-gen

IR generation step of the haloumi lowering pipeline

cranelift-codegen

Low-level code generator library

lexigram

Lexer and LL(1) parser generator

vize_carton

Carton - The artist's toolbox for Vize compiler

archscript

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

eureka-optimizer

A short description

tex_engine

A modular crate for building TeX engines

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.

TypeScript-Rust-Compiler

High-performance TypeScript to Rust compiler

cambridge-asm

Run pseudoassembly from Cambridge International syllabus 9618

swc_transform_common

Common utilities for swc transforms for any language

grammatica

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

som

The 'som' programming language

tsz-parser

TypeScript parser and AST types for the tsz compiler

abacus

The mathemagical programming language

spectral_vm

HYPERION: Production-ready zero-knowledge virtual machine with spectral analysis

mathcompile

High-performance symbolic mathematics with final tagless design, egglog optimization, and Rust hot-loading compilation

mutica

programming language

abyss-lang

AbySS: Advanced-scripting by Symbolic Syntax

oxc_transformer

A collection of JavaScript tools written in Rust

janetrs

High level binding for Janet programming language

cedar-policy-symcc

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

rspression

A high-performance, lightweight expression calculation engine

just-engine

A ground-up ES6 JavaScript engine with tree-walking interpreter, bytecode VMs, and Cranelift JIT compiler

dcim

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

runmat-parser

Parser for RunMat (MATLAB/Octave) producing HIR from token streams

spade-lang

The Spade compiler

draxl

Agent-native source for semantic program control

sema-eval

Trampoline-based evaluator and module system for the Sema programming language

temporaries

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

swipl

A high-level library for building SWI-Prolog extensions and embedding SWI-Prolog in rust applications

typst-batch

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

piccolo

Stackless Lua VM implemented in pure Rust

stacky

Programming Language

ccarp

(trans)Compile C And Rust Partially

lsts

Large Scale Type Systems

netidx-bscript

An incremental scripting language for netidx

turing-lib

Turing library for 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…

analisar

A Lua parser for Rust

flow_parser

Parser for the Flow programming language

modu_ffi

FFI library for modu

typst-svg

SVG exporter for Typst

oak-dhall

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

etcetera-compiler

A Rust-based compiler project

create-farm

Create Farm cli tool

garnish_lang

Single library for re-exporting and documenting all Garnish core libraries

swamp-semantic

semantic types for swamp

parlex

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

chord-progression-parser

a converter from chord progression strings to AST

qir-qis

QIR to Quantinuum QIS (Quantum Instruction Set) compiler

rspack_error

rspack error

ast-demangle

Parses mangled names and produces structured results

hel

HEL — Heuristic Expression Language: a deterministic, auditable expression language & parser, AST, builtin registry and evaluator

treeedb-c

Generate Datalog facts from C source code

leap-lang

Leap language parser

ironmind

A Brainf*ck interpreter and code execution visualizer built in Rust

mun

Command-line interface for compiling, monitoring and running Mun code

ra-ap-rustc_abi

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

cargo_pup_lint_impl

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

cargo-typify

cargo command to generate Rust code from a JSON Schema

dmntk-feel-parser

dmntk | FEEL parser

goboscript

Scratch compiler

harper-comments

The language checker for developers

lovely

A delightful low-level systems programming language

kz80_lua

A Tiny Lua interpreter and compiler for RetroShield Z80

mosaic-lang

A compiler for Mosaic

omg_runtime

The OMG language runtime and virtual machine, providing bytecode execution, REPL, and built-in functions

oxide_lisp

lisp interpreter engine in Rust

rustpython-compiler

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

bcts

Incremental compiler infrastructure using Salsa

logicaffeine-base

Pure structural atoms for logicaffeine - arena, tokens, spans

rustd_cli

Command-line interface for RustD compiler

chalk-recursive

Recursive solver for the Chalk project

reqlang-expr

A tiny (bytecode compiled, stack VM interpreted) expression language for reqlang's templating engine

lean-sys

Bindings to Lean 4's C API

nyar-assembler

Modern Nyar VM assembler - strongly typed, object-oriented, zero-dependency core

hstr

A string type which is optimized for hash operations

aleph-syntax-tree

Aleph Syntax Tree structure

tapir-bf

Tapir is a moderately useful Brainfuck interpreter

intent-codegen

Skeleton code generator for IntentLang specifications (Rust, TypeScript, Python, Go, Java, C#, Swift)

seq-runtime

Runtime library for the Seq programming language

seqlings

Interactive exercises for learning Seq, a stack-based programming language

melody_compiler

The Melody language compiler

dlwrap

dlopen wrapper code generator

unseemly

A typed macro language

motto

Compiler-as-a-Service: Turn Rust schema.rs into multi-platform SDK toolkits

jjik

LR(1) parser generator

gluon_completion

Auto-completion for the gluon programming language

sleigh-compiler

Rust bindings for the Ghidra SLEIGH compiler. Used to compile processor .slaspec files into .sla files

qalam

Interpreter for the Qalam programming language. Qalam is a dead-simple, Urdu inspired, interpreted programming langauge.

blockly-rust-compiler

Rust compiler integration library for visual programming with Blockly - validate and check generated code

teacat