Lib.rs

rustc-hash

A speedy, non-cryptographic hashing algorithm used by rustc

ariadne

A fancy diagnostics & reporting crate

tree-sitter

Rust bindings to the Tree-sitter parsing library

rustc-demangle

Rust compiler symbol demangling

boa_engine

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

apollo-compiler

A compiler for the GraphQL query language

llvm-sys

Bindings to LLVM's C API

swc_ecma_codegen

Ecmascript code generator for the swc project

regalloc2

Backtracking register allocator inspired from IonMonkey

annotate-snippets

building code annotations

codespan

Data structures for tracking locations in source code

tree-sitter-python

Python grammar for tree-sitter

rquickjs

High level bindings to the QuickJS JavaScript engine

rustpython-parser

Python language parser for Python3

jaq-interpret

Interpreter for the jaq language

oxc

A collection of JavaScript tools written in Rust

rustc-stable-hash

A stable hashing algorithm used by rustc

adana

namespaces aliases for command lines & basic scripting language

mers

dynamically typed but type-checked programming language

melior

The rustic MLIR bindings in Rust

apollo-parser

Spec-compliant GraphQL parser

typst-eval

Typst's code interpreter

boa_parser

ECMAScript parser for the Boa JavaScript engine

weval

The WebAssembly partial evaluator

boa_string

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

stak-vm

Virtual machines for Stak Scheme

tlua

Zero-cost high-level wrapper for Tarantool-LuaJIT

gccjit

Higher-level Rust bindings for libgccjit

ra_ap_hir

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

chalk-recursive

Recursive solver for the Chalk project

rustpython-ast

AST definitions for RustPython

dynasmrt

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

clue

C/Rust like programming language that compiles into Lua code

rust-sitter

A package for defining tree-sitter grammars alongside Rust logic

typr

A superset of the legendary R

c2rust

C to Rust translation, refactoring, and cross-checking

type-sitter-cli

CLI for type-sitter (generate typed wrappers for tree-sitter grammars from node-types.json and queries)

three_body_lang

Three Body Language written in Rust

cranelift-frontend

Cranelift IR builder helper

verbena

Scripting language

atc-router

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

rune

Language, an embeddable dynamic programming language for Rust

pandora-interpreter

A command-line tool to run pandora language

clang

A somewhat idiomatic Rust wrapper for libclang

rustlr

Bottom-Up Parser Generator with Advanced Options

semantic-analyzer

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

leo-retriever

A retriever for the Leo programming language

piccolo

Stackless Lua VM implemented in pure Rust

node_resolver

Node.js module resolution algorithm used in Deno

tokay

programming language designed for ad-hoc parsing

vc-ltl

Shared to msvcrt.dll or ucrtbase.dll and optimize the application file size

vrl

Vector Remap Language

dum

An npm scripts runner

spl

Stack Pogramming Language: A simple, concise scripting language

rustc_version_runtime

querying the version of the rustc compiler used in runtime

sus_compiler

Compiler for the SUS Hardware Design Language

ascent

Logic programming in Rust

llvm-ir

LLVM IR in natural Rust data structures

typeset

A DSL for defining source code pretty printers

spirv-cross2

Safe Rust bindings to SPIRV-Cross

axolotlsay

💬 a CLI for learning to distribute CLIs in rust

from-pest

Convert from a pest grammar to a typed AST

ra-ap-rustc_lexer

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

rgsm

An assembler for the Gheith ISA written in Rust

turbofuro_worker

Worker executable for Turbofuro

chalk-engine

Core trait engine from Chalk project

spirt

Shader-focused IR to target, transform and translate from

tree-sitter-java

Java grammar for tree-sitter

erg_compiler

Centimetre: the Erg compiler

generic-lang

A Lox based programming language

ruwren

bindings to Wren programming language

lambda_mountain

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

pen-ffi

FFI library for Pen programming language

wright

programming language compiler and tooling

adam

A command-line interface for compiling Gms2 projects

mini-c-parser

minimal C language lexer & parser & virtual executer from scratch

cambridge-asm

Run pseudoassembly from Cambridge International syllabus 9618

endbasic

programming language - CLI

typst-realize

Typst's realization subsystem

garnish_lang_compiler

Utilites to compile garnish scripts

swc_ecma_visit

Visitors for swc ecmascript nodes which works on stable rustc

cxxbridge-flags

Compiler configuration of the cxx crate (implementation detail)

goboscript

Scratch compiler

tremor-script

Tremor Script Interpreter

p2sh

Programming language interpreter

dylint-link

A wrapper around Rust's default linker to help create Dyling libraries

ra_ap_parser

parser for rust-analyzer

janetrs

High level binding for Janet programming language

swc-plugin-inferno

SWC plugin for InfernoJS

kronk

interpreter - a silly, experimental language with surprisingly loud output

ironmind

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

blisp

A lisp like statically typed programing language for no_std

heraclitus-compiler

Compiler frontend for developing great programming languages

tket2

Quantinuum's TKET2 Quantum Compiler

garble_lang

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

crunch-app

Turbocharge your Rust workflow with crunch

maolang

A language with dynamic and annoying rules

uiua

A stack-based array programming language

hclua

tan

language

flexar

An extremely flexible lexer/parser (get it?) for writing your own programming language

gluon

A static, type inferred programming language for application embedding

farmfe_swc_transformer_import_glob

farm swc tranformer for vite-style import.meta.glob

cmtc

compiler providing cmtir-based passes to generate backends including FIRRTL, SystemVerilog and simulators

kn-cuda-eval

A CUDA executor for neural network graphs

quickjs-rusty

QuickJS (QuickJS-NG) Javascript engine wrapper, and more

diplomat

FFI generation macro

melody_compiler

The Melody language compiler

gabelang

A high level, interpretted and garbage collected programming language

calcit

Interpreter and js codegen for Calcit

bfjit

Brainfuck JIT VM tutorial

rb-sys

Rust bindings for the CRuby API

cranelift-native

Support for targeting the host with Cranelift

swipl

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

fn_vm

A lightweight frame based virtual machine, meant as the base for rigz_vm

airlang

The Air Programming Language

bund

Interpreter and CLI for a Virtual Machine for BUND programming language

typst-layout

Typst's layout engine

stak

Stak Scheme interpreter

aspl

Programming Language

csml_engine

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

rolldown-ariadne

A fancy diagnostics & reporting crate

lisp-rs

Lisp interpreter in Rust

vc_8bit

This project is a virtual computer that takes a vector of bytes and runs it as instructions. Also included is a complete assembler and compiler.

jsompiler

a Json syntax programming language for Windows

netsblox-ast

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

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.

pliron

Programming Languages Intermediate RepresentatiON

argus-lib

Trait debugger analysis for IDE interactions

passerine

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

b2c2-compiler

b2c2におけるBASICコードをCASL2に変換する部分?

cppcheckr

cpp file tester for competetive programing

ccarp

(trans)Compile C And Rust Partially

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

atlas_77

Functional programming language with strong interoperability with Rust

swamp-script-core-extra

core parts for swamp evaluator

som

The 'som' programming language

phoenix-lang

fast programming language

cyclang

toy language built in LLVM

boof

A Brainfuck interpreter, and also a dog

cexpr

A C expression parser and evaluator

koopa

generating/parsing/optimizing Koopa IR

slac

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

brainf-ck-rs

A brainfuck interpreter with a visualizer

deno_webidl

WebIDL implementation for Deno

typespec_client_core

Client runtime for TypeSpec-generated libraries

rustpython-unparser

A complete unparser for RustPython ASTs

sdml-parse

Parser for Simple Domain Modeling Language (SDML)

ellie_engine

Why ellie? Ellie is a type-safe programing language that runs on embedded and sandboxed environments

ra-ap-rustc_abi

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

starlark

language in Rust

whitespacers

A whitespace JIT-compiler, for when your whitespace just isn't executing fast enough

deoptimizer

machine code de-optimizer. By transforming/mutating the machine code instructions to their functional equivalents it makes possible to bypass pattern-based detection mechanisms used by security products.

brainfoamkit

An interpreter for the brainf*** language

chalk-ir

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

rust_lisp

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

rever

Interpreter and REPL for the Rever language

lib-ruby-parser-nodes

Ruby parser nodes data

rasm-lang

RASM is a small Interpreted Programming Language

wild-linker

A very fast linker for Linux

qbe

QBE IR for Rust

wson_rs

WSON data serialization parser

polonius-engine

Core definition for the Rust borrow checker

rustpython-parser-vendored

RustPython parser vendored third-party crates

espr

EXPRESS Language compiler

clang-sys

Rust bindings for libclang

glslang

Rust bindings to glslang

chord-progression-parser

a converter from chord progression strings to AST

codespan_preprocessed

Beautiful diagnostic reporting for M4 (or cpp) preprocessed text files

lead_lang_interpreter

Interpreter of the Lead Programming Language

cranelift-assembler-x64-meta

Generate a Cranelift-specific assembler for x64 instructions

nu-cmd-lang

Nushell's core language commands

aplang

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

sap-cli

The command line interface for the SAP programming language

evcxr

An Evaluation Context for Rust

logics-rs

Logics is a user-friendly formula language with a subset of Python's expression syntax

cmajor

Rust bindings for the Cmajor JIT engine

kdl-script

execute kdl documents!

relo

A custom programming language with a readable syntax (RELO)

fta

Fast TypeScript Analyzer

resw

writing RESSA AST parts to a file

b3

port of B3 WebKit codegen backend

react_remove_properties

AST Transforms for import modularizer

tket-json-rs

Serializable definition of TKET circuits and operations

termslang

The terms programming language

walc_model

Interpreter for Walc programming language

faye

a pretty lil lisp

ergotree-ir

ErgoTree IR, serialization

quoth

scannerless (no-lexing), developer-friendly parsing library for implementing DSLs and syntax parsers in Rust

symboscript-formatter

SymboScript formatter

koto

expressive, embeddable programming language

mlua-extras

Extra helpers and functionality built on top of mlua for embedded lua development

dust_dds_gen

OMG IDL compiler for Dust DDS

nyxstone

Bindings for the nyxstone assembler/disassembler

cellang

Interpreter for the CEL expression language

swamp-script-parser

parser for swamp script

garden-lang

A live programming language

swc_ecma_loader

General ecmascript loader used for transforms

oxc_transformer

A collection of JavaScript tools written in Rust

analisar

A Lua parser for Rust

egglang

The Egg Programming Language From Eloquent JavaScript, but in Rust

vbscript

lexer and parser

spade-ast

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

erg

programming language

rspack_hash

rspack hash

fucker

BrainFuck interpreter and optimizing JIT compiler

fuyuc

The Fuyu programming language compiler

myexe

Myexe

gramma

Generate a scannerless parser by declaring types

py-declare

type declare system for pycc-rs

typespec

Project root for all TypeSpec-related crates

stella_checker

Rust-based, speedy Lua type checker

llvm-lib

LLVM library with safe and flexibility in mind, without over complexity based on LLVM-C API

r2u2_cli

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

netidx-bscript

An incremental scripting language for netidx

zung

A monolith of rust projects

script-format

DSL to format data via rhai scripting

cranelift-codegen

Low-level code generator library

strop

stochastically generates machine code

impc

A compiler for the IMP programming language

poetic

parse and interpret poetic source code

rustc_lexer

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

tinymist-assets

assets for tinymist

turing-lib

Turing library for Rust

mxmlextrema-as3parser

ActionScript 3 parser

typst-library

Typst's standard library

pstd

parts of Rust std library ( different implementations, features not yet stabilised etc )

scoutlang

A web crawling programming language

qalam

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

recc

A C compiler with graphs

badder_lang

A specialized programming language built for programming puzzle game Robo Instructus

cproj-rs

A basic c/c++ build tool

hecate-bf

A brainfck to hasm compiler for the hecate vm

cranelift-jit

A JIT library backed by Cranelift

codesnake

Pretty printer for non-overlapping code spans

claw-common

The Claw language common types and functions

hydroflow

Hydro's low-level dataflow runtime and IR

michaelb/sniprun

A neovim plugin to run lines/blocs of code (independently of the rest of the file), supporting multiples languages

bpf-ins

working with eBPF instructions

cbvm

Cross bytes virtual machine used for building, running and reading CBVM files

nessa-language

An extensible programming language with a strong type system

backyard-generator

Convert AST node back to PHP code

c64-assembler

Commodore 64 assembler, outputs directly to .PRG or Dasm source code

farmfe_compiler

Farm Compiler

hi-doc

Diagnostics formatting library

spyglys

programming language for text manipulation

riji

Scripting environment using rhai

torq_lang

A programming language for concurrent dataflow

irvm

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

ergoscript-compiler

Compiler for ErgoScript

hugr

Quantinuum's Hierarchical Unified Graph Representation

glass-easel-template-compiler

The template compiler of the glass-easel project

leo-disassembler

A disassembler for the Leo programming language

backus_naur_form_parser_and_compiler

A parser and compiler that uses Backus Naur Forms to create the AST with a option to compile the AST

bnf_rules

LR(1) parser generator

mago-parser

A fast, recursive descent parser for PHP

gosyn

Golang syntax parser in Rust

astray

Easily define AST using only Rust structures

bpfjit-sys

Rust bindings to NetBSD's cBPF JIT engine

midenc-hir-analysis

Analysis passes and utilties for Miden HIR

tapir-bf

Tapir is a moderately useful Brainfuck interpreter

iodine

Stack-based programming language

chimpanzee

Monkey programming language implementation (interpreter, compiler and formatter), with added features

eira

Ansi-colored error reporting output

type-sitter

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

lex

aids in parsing programming languages

garnish_lang_simple_data

Data implementation for garnish runtimes using simple list of variants

source-span

Source code mapping and display utilities

temporaries

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

ape_lexer

lexical analysis for Aperture programming language

tergo-tokenizer

R language tokenizer

leap-lang

Leap language parser

to_method

micro-crate for using Into more ergonomically

lush

lua for shell scripts - embedded in a single binary, easy to share, to run everywhere

vyder

Create custom libraries for vyder

diplomat-runtime

Common runtime utilities used by diplomat codegen

nu-std

The standard library of Nushell

libbfi

Extendable brainfuck interpreter library

stack-vm

A generic, reusable, stack-based virtual machine

ast-demangle

Parses mangled names and produces structured results

mech

reactive programming language for building robots, games, and animations

mosaic-lang

A compiler for Mosaic

class-rs

Reads/writes a .class file into/from an almost 1-to-1 matching struct

alicorn

Rust embedding of the Alicorn compiler

sdml-errors

Domain Modeling Language (SDML) errors and diagnostics

m68000

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

kn-cuda-sys

A wrapper around the CUDA APIs

quickjspp

QuickJS Javascript engine wrapper using quickjs fork named quickjspp

unseemly

A typed macro language

lang-interpreter

reimplementation of the Standard Lang interpreter

brainfork

A compiler for Brainfuck written in Rust

c2rust-ast-builder

Rust AST builder support crate for the C2Rust project

lua_parser

syntax parser for lua language

mir-rs

FFI bindings to MIR Project (https://github.com/vnmakarov/mir)

mech-range

Range library for the Mech language

typlite

Converts a subset of typst to markdown

jinko

safe, small and fast programming language with Rust interoperability

ezno

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

harper-html

The language checker for developers

cfi-types

CFI types for cross-language LLVM CFI support

hax-frontend-exporter

mirrors of the algebraic data types used in the Rust compilers, removing indirections and inlining various pieces of information

hive-engine

A game engine for Hive

steel-core

Core compiler and VM implementation for steel

lib-cargo-crate

The lib for cargo-crate

sddrs

Bottom-up Sentential Decision Diagram compiler library

bytevm

A tiny bytecode virtual machine

xee-interpreter

Interpreter for XPath and XSLT

ocaml-gen

generating OCaml code

xasm-rs

generating linux 32/64 bit assembly easily

fennec

Programming Language

libket

Runtime library for the Ket programming language

pseudo_interpreter

A Pseudocode interpreter

umpl

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

rusche

A lightweight Scheme interpreter embeddable in Rust applications

bappy-script

Gankra's toy compiler

penne

pasta-oriented programming language that favors the goto-statement for flow control

gramatika

A minimal toolkit for writing parsers with Rust

remolt

Embeddable TCL-ish interpreter for Rust applications

nb2pb

Compiles NetsBlox projects into PyBlox projects

typst-html

Typst's HTML exporter

dfir_rs

DFIR runtime for Rust, used by Hydro

syntax-parser-generator

Independent library for generating lexical-analyzers and LALR parsers

oxc_codegen

A collection of JavaScript tools written in Rust

rustc_plugin

A framework for writing plugins that integrate with the Rust compiler

awa5_rs

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

nope-lang

The nope programming language

chalk-solve

Combines the chalk-engine with chalk-ir

spade-parser

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

ra_ap_tt

A TokenTree data structure for rust-analyzer

my_tuple

A pretty implementation of tuple

fb_cloned

Cloned macro

santiago

A lexing and parsing toolkit for Rust

llvm-bitcode

LLVM Bitcode parser in Rust

dunh

Highlights code for printing

decomp

Components of a decompilation pipeline

antimony-lang

The Antimony programming language

modu-no-nightly

A fast and simple interpreted language (dosent have modu server but dosent need nightly)

lexerus

annotated lexer

tr-lang

A programming language made to bring syntax closer to Turkish

moparse

Modelica language parser

beans

A parser generator library based on the Earley parser

b2c2-debugger

CASL2のコードを雑雑に実行テストするCOMET2シミュレーター(エミュレーター?)もどき

makepad-live-compiler

Makepad platform live DSL compiler

duskphantom-backend

Backend for DuskPhantom Compiler

clutils

A common library for building interpreter and compiler

pocketbrain

A fast Brainfuck interpreter

hecate-common

Common data structures for the hecate vm

nadesiko3

Japanese programming language Nadesiko v3

scrapile

A somewhat fully-fleged rust-like programming language that, surprisingly, compiles to scratch

langen

create programming languages

cargo-typify

cargo command to generate Rust code from a JSON Schema

lemonlang

an experimental, modern, purely safe, programming language

spaik

Programming Language

emit-jvm-bytecode

Emit class files and JVM bytecode

oxygenlance

run BF Joust matches in Rust

lep

Mini language for interactive consoles, featuring small code footprint

mec

mruby/edge compiler cli endpoint

Cecile

Cecile Programming Language that is designed to be simple, fast

abyss-lang

AbySS: Advanced-scripting by Symbolic Syntax

minicode

Esoteric programming language

shiftkit

A quick & easy parser generator

rs-luau

Minimal overhead Luau bindings for Rust!

wmlua

ara_parser

A fault-tolerant, recursive-descent parser for Ara Programming Language 🌲

fexplib

lower-house syntax for programming language experimentation

lambda-types

Puts the lambda calculus in Rust...'s type system

simple-vm

bytecode VM with a custom compiler

diatom

programming language

gs2compiler

Compiles GS2 source code into GS2 bytecode

sparta

software components specially designed for building high-performance static analyzers based on the theory of Abstract Interpretation

static-reflect

Static type information, giving a form of compile-time reflection

kn-graph

A neural network inference graph intermediate representation, with surrounding utilities

stak-compiler

Stak Scheme bytecode compiler

swamp-script-node

compiler node with documentation and meta information

hax-driver

The custom rustc driver used by hax

mijit

Experimental JIT compiler generator

as3_parser

ActionScript 3 parser

langbox

framework to build compilers and interpreters

math-jit

Compile arithmetic expressions to native code

langlang_syntax

langlang is a parser generator based on Parsing Expression Grammars (library)

java-lang

用于rust的java语法解析器。根据Java 23 规范实现。

rzsc

@RZ Script Compilers

slotted-egraphs

E-Graphs with name binding

sourcepawn_lexer

Lossless SourcePawn lexer