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

swc_ecma_codegen

Ecmascript code generator for the swc project

apollo-parser

Spec-compliant GraphQL parser

ena

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

melior

The rustic MLIR bindings in Rust

oxc

A collection of JavaScript tools written 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.

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

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

erg

programming language

mago-reporting

Structured error and diagnostic reporting utilities

cel

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

c2rust

C to Rust translation, refactoring, and cross-checking

cranelift-frontend

Cranelift IR builder helper

spirt

Shader-focused IR to target, transform and translate from

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

jstime

JS Runtime

kc

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

vrl

Vector Remap Language

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

sus_compiler

Compiler for the SUS Hardware Design Language

pandora-interpreter

A command-line tool to run pandora language

thot

An asm

kz80_lisp

A minimal LISP interpreter and compiler for RetroShield Z80

atoxide-cli

Atopile compiler CLI

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

three_body_lang

Three Body Language written in Rust

rspack_hash

rspack hash

clue

C/Rust like programming language that compiles into Lua code

ra-ap-rustc_lexer

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

boa_parser

ECMAScript parser for the Boa JavaScript engine

lua2hcb_compiler

A compiler for Lua-like scripts to HCB

rumoca

Modelica compiler written in RUST

lambda_mountain

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

from-pest

Convert from a pest grammar to a typed AST

typst-pdf

PDF exporter for Typst

mers

dynamically typed but type-checked programming language

logicaffeine-compile

LOGOS compilation pipeline - codegen and interpreter

cranelift-native

Support for targeting the host with Cranelift

kansei

programming language

atc-router

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

diplomat

FFI generation macro

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

chap

easy to learn, interpretive, scripting language written in Rust

python-ast

compiling Python to Rust

type-sitter

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

depyler-annotations

Annotation parsing and processing for Depyler

run

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

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

rapx

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

typst-assets

Assets for the Typst compiler

wright

programming language compiler and tooling

typespec_client_core

Client runtime for TypeSpec-generated libraries

generic-lang

A Lox based programming language

heraclitus-compiler

Compiler frontend for developing great programming languages

stak-vm

Virtual machines for Stak Scheme

rustpython-ast

AST definitions for RustPython

antimony-lang

The Antimony programming language

node_resolver

Node.js module resolution algorithm used in Deno

cxxbridge-flags

Compiler configuration of the cxx crate (implementation detail)

sema-lang

Sema — a Lisp dialect with first-class LLM primitives

phper

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

mago-syntax

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

rustcc

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

hugr

Quantinuum's Hierarchical Unified Graph Representation

clr-assembler

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

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

scryer-prolog

A modern Prolog implementation written mostly in Rust

garble_lang

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

netsblox-ast

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

llvm-ir

LLVM IR in natural Rust data structures

midenc-log

flexible trace logging for midenc

swc_core

TBD

pliron

Programming Languages Intermediate RepresentatiON

lamina

High-performance compiler backend for Lamina Intermediate Representation

clang-sys

Rust bindings for libclang

jsonpiler

a Json syntax programming language for Windows

brainfoamkit

An interpreter for the brainf*** language

xbasic64

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

cargo-slicer

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

pipeline-script

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

chalk-ir

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

llts

TypeScript to native compiler via LLVM

python-rs

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

bop-cli

CLI and REPL for the Bop programming language

tket-json-rs

Serializable definition of TKET circuits and operations

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

neorusticus

A Prolog implementation in Rust with enhanced error handling

mimium-lang

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

kz80_c

A self-hosting C compiler for Z80 targeting RetroShield hardware

cyclang

toy language built in LLVM

swc_ecma_transforms_typescript

rust port of babel and closure compiler

java_asm

Java bytecode reader & writer in rust

glslang

Rust bindings to glslang

bend-lang

A high-level, massively parallel programming language

plotnik-compiler

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

rspack_plugin_css

rspack css plugin

zetac

The final systems language

lumen-compiler

The AI-Native Programming Language

spl

Stack Pogramming Language: A simple, concise scripting language

atlas_77

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

fastc-lsp

Language Server Protocol implementation for FastC

rune_c_compiler

A Rune to C source file compiler

pixelscript

Multi language scripting runtime

progenitor-middleware

An OpenAPI client generator

seq-core

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

dust_dds_gen

OMG IDL compiler for Dust DDS

a2x

A converter from ALFA to XACML policy language

wadl

parser for Rust

cloudrun-test-rust

Basic Hello world Rust for tesing Cloud Run

fta

Fast TypeScript Analyzer

netidx-bscript

An incremental scripting language for netidx

faye

a pretty lil lisp

deno_webidl

WebIDL implementation for Deno

guryvsr

esoteric programming language gur yvsr

runmat-ignition

Baseline interpreter for RunMat enabling instant startup and execution

ascent

Logic programming in Rust

pyimports

Parse and analyze the imports within a python package

m68000

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

quickjs_runtime

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

turbofuro_worker

Worker executable for Turbofuro

steel-core

Core compiler and VM implementation for steel

seqlings

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

gluon_c-api

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

jexl-parser

A JEXL parser written in Rust

rustpython-compiler

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

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

windjammer

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

ocaml-gen

generating OCaml code

oxc_parser

A collection of JavaScript tools written in Rust

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

TypeScript-Rust-Compiler

High-performance TypeScript to Rust compiler

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 c2c6f74fd2216a63c7d180d5dda4c825d503c2fa The publishing script for this crate lives at:…

spade-ast

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

mini-c-parser

minimal C language lexer & parser & virtual executer from scratch

mux-lang

The Mux Programming Language Compiler

slac

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

hi-doc

Diagnostics formatting library

xdy

Complex RPG dice expression evaluator with histogram support

mech

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

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

codemem-index

Tree-sitter code indexing for Codemem memory engine

diplomat-runtime

Common runtime utilities used by diplomat codegen

dlexer

A high-performance, functional parser combinator library for Rust

wasc

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

cranelift-jit

A JIT library backed by Cranelift

cc2600

a subset of C compiler for Atari 2600

ra_ap_hir_def

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

vize_atelier_vapor

Atelier Vapor - The Vapor mode compiler workshop for Vize

chapter3_lexical

A lexical analyzer that returns the tokens you wrote!

bund

Interpreter and CLI for a Virtual Machine for BUND programming language

cudaforge

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

lisp-rs

Lisp interpreter in Rust

cortex-lang

interpreted language for interfacing with Rust code

cedar-policy-symcc

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

calcit

Interpreter and js codegen for Calcit

flowistry

Modular information flow analysis

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

qbe

QBE IR for Rust

nashc

Compiler for the nash programming language

r2u2_cli

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

surreal-lang

A Rust-inspired language for the BEAM

mystsh

Mystical shell parser, formatter, and interpreter with Bash support

oonta

OCaml (subset) to LLVM IR compiler front-end

soppo

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

vegen

A compiler for tiny, efficient, updatable TypeScript HTML templates

preinterpret

An intuitive toolkit to simplify code generation development

uiua

A stack-based array programming language

edlc_lsp

EDLc Language Sever Protocol implementation

adana-cache-command

namespaces aliases for command lines & basic scripting language

scopegraphs

A well-documented port of scopegraphs to Rust

rustc_lexer

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

type-bridge-core-lib

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

cgrammar

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

procss

CSS parsing and transformation framework

hmacro

macro preprocessor

olotin1

splik

programming language identifier kit

archscript

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

jasm-assembler

Modern assembler for JVM instruction set - strongly typed, object-oriented, zero-dependency core

monkey-parser

a parser for monkey lang

amethyst_geode

Turing Machine Programming Language Interpreter

hel

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

tket

Quantinuum's TKET Quantum Compiler

zia

Interpreter Library for the Zia Programming Language

galvan

A higher-level programming language that transpiles to Rust

polonius-engine

Core definition for the Rust borrow checker

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)

sevenmark-parser

Core parsing engine for SevenMark wiki markup

koopa

generating/parsing/optimizing Koopa IR

verter_core

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

csw-cli

Command-line interface for the Categorical Semantics Workbench

libwild

that provides a fast Linux linker

qvcm

Register-based bytecode VM with quantum computing functionality

danwi

SI units library

endbasic

programming language - CLI

corvo7

A toy programming language compiler written in Rust

gabelang

A high level, interpretted and garbage collected programming language

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)

tart

compiling and linking code written in multiple languages by their native toolchains

plotnik-vm

Runtime VM for executing compiled Plotnik queries

hilang

A small programming language

tinymist

An integrated language service for Typst

lexit

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

mblf

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

garden-lang

A live programming language

just-engine

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

lucia-lasm

LASM - Lucia Assembly Language

single-variable-algebra-compiler

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

ilm

A fun programming language with Islamic terminology

diffsl

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

umjunsik

Language compiler targeting Lamina IR

metaslang_stack_graphs

Stack graphs utilities used in Slang

aver-lang

Interpreter for Aver, a programming language designed for AI-assisted development

pascal

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

vize_atelier_ssr

Vue SSR compiler for Vize

fusabi-frontend

Frontend (parser, compiler) for Fusabi language

stck

An embeddable interpreted language written fully in rust

somni-parser

Grammar parser of the Somni language and VM

codanna

Code Intelligence for Large Language Models

asg-lang

ASG - A programming language built on Abstract Syntax Graph

ruchy

A systems scripting language that transpiles to idiomatic Rust with extreme quality engineering

forge-lang

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

fift-cli

A CLI for the Fift esoteric language interpreter

rma-parser

Tree-sitter based polyglot parser for Qryon

rust_lisp

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

hclua

kind2

A pure functional functional language that uses the HVM

mathcompile

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

simpleton

runner for Intuicio scripting platform

MotoGarage_parser

A parser and interpreter for MotoGarage DSL, a language for managing motorcycle collections

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

stak-device

Devices for Stak Scheme

tsz-parser

TypeScript parser and AST types for the tsz compiler

aplang

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

leo-interpreter

Interpreter for the Leo programming language

rustc_utils

working with the Rust compiler

littrs-ruff-python-parser

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

resrap-rs

A rule based code generator

horkos

Cloud infrastructure language where insecure code won't compile

vbscript

lexer and parser

tremor-script

Tremor Script Interpreter

maid-lang

Maid Programming Language

bhc-ast

Abstract syntax tree definitions for BHC

lex

aids in parsing programming languages

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.

modu_ffi

FFI library for modu

haloumi-ir-gen

IR generation step of the haloumi lowering pipeline

swipl

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

cranelift-codegen

Low-level code generator library

lexigram

Lexer and LL(1) parser generator

eureka-optimizer

A short description

tex_engine

A modular crate for building TeX engines

typr

A typed superset of R - transpiler and type checker

swc_transform_common

Common utilities for swc transforms for any language

som

The 'som' programming language

janetrs

High level binding for Janet programming language

mago-span

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

spectral_vm

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

mutica

programming language

abyss-lang

AbySS: Advanced-scripting by Symbolic Syntax

grammatica

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

analisar

A Lua parser for Rust

tensorlogic-cli

TensorLogic command-line interface and library for compiling logical expressions to tensor graphs

motto

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

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

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.

bashrs

Rust-to-Shell transpiler for deterministic bootstrap scripts

typst-batch

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

create-farm

Create Farm cli tool

oxc_transformer

A collection of JavaScript tools written in Rust

stacky

Programming Language

kz80_lua

A Tiny Lua interpreter and compiler for RetroShield Z80

lsts

Large Scale Type Systems

cambridge-asm

Run pseudoassembly from Cambridge International syllabus 9618

lovely

A delightful low-level systems programming language

turing-lib

Turing library for Rust

xlsynth-pir

partial XLS IR focused on functions

typst-svg

SVG exporter for Typst

etcetera-compiler

A Rust-based compiler project

ra-ap-rustc_abi

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

piccolo

Stackless Lua VM implemented in pure Rust

garnish_lang

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

swamp-semantic

semantic types for swamp

harper-comments

The language checker for developers

parlex

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

ast-demangle

Parses mangled names and produces structured results

chord-progression-parser

a converter from chord progression strings to AST

goboscript

Scratch compiler

rspack_error

rspack error

omg_runtime

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

cargo_pup_lint_impl

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

mun

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

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

bop-lang

A small, dynamically-typed programming language

cargo-typify

cargo command to generate Rust code from a JSON Schema

dmntk-feel-parser

dmntk | FEEL parser

mech-set

Set library for the Mech language

dlwrap

dlopen wrapper code generator

mosaic-lang

A compiler for Mosaic

oxide_lisp

lisp interpreter engine in Rust

prune-lang

Prune is a constraint logic programming language with branching heuristic

bcts

Incremental compiler infrastructure using Salsa

qalam

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

logicaffeine-base

Pure structural atoms for logicaffeine - arena, tokens, spans

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

hstr

A string type which is optimized for hash operations

aleph-syntax-tree

Aleph Syntax Tree structure

rosetta-stone-core

Core types and traits for the Rosetta transpiler

tapir-bf

Tapir is a moderately useful Brainfuck interpreter

marzipan

A macro processor for ZZT worlds

oxur

Lisp dialect that treats Rust as its compilation target and runtime

melody_compiler

The Melody language compiler

vize_relief

Relief - The sculptured AST surface for Vize Vue templates

jjik

LR(1) parser generator

quickjspp

QuickJS Javascript engine wrapper using quickjs fork named quickjspp

unseemly

A typed macro language

gluon_completion

Auto-completion for the gluon programming language

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…

sleigh-compiler

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

c2rust-ast-builder

Rust AST builder support crate for the C2Rust project

orco

A compiler backend interface

run-kit

Universal multi-language runner and smart REPL

gluon

A static, type inferred programming language for application embedding

blockly-rust-compiler

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

teacat

A modern and powerful templating language

miden-field-repr

Serialization/deserialization for felt representation

snli

An interpreter for the Syntax Null Language Esolang

qir-qis

QIR to Quantinuum QIS (Quantum Instruction Set) compiler

resw

writing RESSA AST parts to a file

aegis-lang

A dynamic, interpreted programming language with a high-performance bytecode VM

sql-ast

A lean sql AST and parser

kombucha

A minimal and malleable programming language for symbiotic end-user programming

umpl

meme language that is a mix of c like languages and lisp like languages

rusty-basic

Tiny BASIC interpreter written in Rust

lu

embedding Luau

nessa-language

An extensible programming language with a strong type system

aardvark-core

Runtime for executing sandboxed python bundles inside V8

koto

expressive, embeddable programming language

ezno

A fast and correct TypeScript type checker and compiler with additional experiments. For use as a library or through the CLI

tket-qsystem

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

light_ranged_integers

Ranged integers for stable Rust compiler, zero-dependencies and no unsafe code

koto_bytecode

The bytecode compiler used by the Koto programming language

lux-lang

The Lux programming language

vyder

Create custom libraries for vyder