Langdev libraries for Rust

• Lexers
• Parsers
• Codegen
• String interning
• Just-in-time compilation
• Error reporting
• Language server protocol
• Testing
• Incremental compilation
• Floats/Ints/Bools
• Binary & object file parsing, generating and processing
• Solvers
• CLI
  • Configuration
• Repl
• String handling
• Syntax trees
• Pretty printing
• Variable binding
• Caching
• WASM
• Logging
• Storage
  • Disjoint-sets
• Incremental Analysis
  • Timely Dataflow Resources
• Fuzzing
  • Fuzzing Resources
• Graphs
• Type Checking
• Peephole Optimization
• Garbage Collection
• Guides & Resources
  • Type Checking
  • Inlining
  • RVSDG
  • Equality Saturation
• Uncategorized

Lexers

• logos Logos has two goals: To make it easy to create a Lexer, so you can focus on more complex problems and to make the generated Lexer faster than anything you'd write by hand
• lrlex A replacement for lex/flex that generates Rust code
• lexgen A fully-featured lexer generator, implemented as a proc macro.

Parsers

• lalrpop A convenient LR(1) parser generator
• nom A byte-oriented, zero-copy, parser combinators library
• combine Fast parser combinators on arbitrary streams with zero-copy support.
• pom PEG parser combinators using operator overloading without macros.
• peg A simple Parsing Expression Grammar (PEG) parser generator.
• glue Glue is a parser combinator framework for parsing text based formats, it is easy to use and relatively fast too
• pratt A general purpose pratt parser for Rust
• pest A general purpose parser written in Rust with a focus on accessibility, correctness, and performance using parsing expression grammars (PEG)
• lrpar A Yacc-compatible parser.
  • nimbleparse_lsp An LSP server for quickly developing lrpar parsers, which parses input buffers on grammar change bypassing code generation.
• tree-sitter A parser generator for building fast editor-friendly parsers with features like streaming, incremental, resumable (re)parsing, with timeouts and cancellations, and advanced syntax node queries.
• rowan Generic lossless syntax trees
  • ungrammar A DSL for specifying concrete syntax trees, see this introductory post
• cstree A fork of rowan with threadsafe syntax trees and built-in source string interning
• chomp Chomp is a fast monadic-style parser combinator library designed to work on stable Rust
• oak A typed parser generator embedded in Rust code for Parsing Expression Grammars
• chumsky A friendly parser combinator crate that makes writing LL(k) parsers with error recovery easy
• rust-sitter A package for defining tree-sitter grammars alongside Rust logic

Regular expressions

• regex An implementation of regular expressions for Rust. This implementation uses finite automata and guarantees linear time matching on all inputs.
• regress A regular expression engine targeting EcmaScript syntax.
• onig Rust-Onig is a set of Rust bindings for the Oniguruma regular expression library.

Codegen

• cranelift Cranelift is a low-level retargetable code generator
• llvm-sys Bindings to LLVM's C API
• iced-x86 A blazing fast and correct x86/x64 disassembler, assembler and instruction decoder
• llama Friendly LLVM bindings
• inkwell Inkwell aims to help you pen your own programming languages by safely wrapping llvm-sys
• llvm-ir LLVM IR in natural Rust data structures
• llvmenv Manage multiple LLVM/Clang builds
• walrus A library for performing WebAssembly transformations
• cilk Toy Compiler Infrastructure influenced by LLVM written in Rust.

String interning

• lasso A multithreaded and single threaded string interner with a minimal memory footprint and arena allocation
• string-interner A data structure to cache strings efficiently
• simple-interner A simple append-only interner
• string_cache A string interning library for Rust, developed as part of the Servo project

Just-in-time Compilation

• iced-x86 A blazing fast and correct x86/x64 disassembler, assembler and instruction decoder
• masm-rs A JSC/SpiderMonkey like macro assembler
• b3 Rust port of B3, LLVM-like backend
• jit (LibJIT) Just-In-Time Compilation in Rust using LibJIT bindings
• lightning-sys GNU lightning bindings for rust
• gccjit Higher-level Rust bindings for libgccjit
• cranelift Cranelift is a low-level retargetable code generator
  • cranelift-jit-demo A JIT compiler and runtime for a toy language, using Cranelift
• dynasm A Dynamic assembler written in Rust for Rust

Error reporting

• codespan-reporting Beautiful diagnostic reporting for text-based programming languages
• codespan Data structures for tracking locations in source code
• text-size A library that provides newtype wrappers for u32 and (u32, u32) for use as text offsets
• ariadne A fancy diagnostics & reporting crate
• miette Fancy diagnostic reporting library and protocol for us mere mortals who aren't compiler hackers

Language server protocol

• lsp-types Types for interaction with a language server, using VSCode's Language Server Protocol
• tower-lsp Language Server Protocol implementation based on Tower
• codespan-lsp Conversions between codespan types and Language Server Protocol types
• lsp-server A generic LSP server scaffold

Testing

• goldentests A golden file testing library where tests can be configured within the same test file
• lang_tester Concise language testing framework for compilers and VMs (Linux only)
• libtest-mimic Dynamically construct a test-harness that looks and behaves like Rust's built-in test harness
• compiletest_rs The compiletest utility from the Rust compiler as a standalone testing harness
• insta A snapshot testing library for Rust
• k9 Snapshot testing and better assertions
• bulk_examples_generator A tool created in Rust for create dozens/hundreds/thousands/millions of random examples based on a pest grammar (PEG)

Unicode

• unicode-xid Determine if a char is a valid identifier for a parser and/or lexer according to Unicode Standard Annex #31 rules.
• unicode-normalisation Unicode character composition and decomposition utilities as described in Unicode Standard Annex #15
• unicode-segmentation Iterators which split strings on Grapheme Cluster or Word boundaries, according to the Unicode Standard Annex #29 rules
• unicode-width Determine displayed width of char and str types according to Unicode Standard Annex #11 rules
• lexical-sort Lexicographical sorting of unicode strings

Incremental compilation

• salsa A generic framework for on-demand, incrementalized computation
• verde A refreshingly simple incremental computation library

Floats/Ints/Bools

• lexical Lexical, to- and from-string conversion routines (Fast lexical conversion routines for both std and no_std environments)
• lexical-core Lexical, to- and from-string conversion routines (Low-level, lexical conversion routines for use in a no_std context)
• lexical_bool A bool-like type that can be parsed from a string
• ryu A Rust implementation of the PLDI'18 paper Ryū: fast float-to-string conversion by Ulf Adams
• ryu-js Ryū-js is a fork of the ryu crate adjusted to comply to the ECMAScript number-to-string algorithm
• hexponent C11 compliant hex float parsing
• ordered-float Total ordering on floats
• half A half-precision floating point f16 type for Rust implementing the IEEE 754-2008 standard
• f128 Bindings to the gcc quadmath library
• approx Approximate floating point equality comparisons and assertions

Binary & object file parsing, generating and processing

• goblin An impish, cross-platform, ELF, Mach-o, and PE binary parsing and loading crate
• gimli A library for reading and writing the DWARF debugging format.
• faerie ELF and Mach-o native binary object file emitter
• object A unified interface for reading and writing object file formats.
• elf A pure-rust library for parsing ELF files
• elfkit An elf parser and manipulation library in pure rust

Symbolic Execution

• haybale Symbolic execution of LLVM IR

Solvers

• rsmt2 Wrapper for SMT-LIB 2 compliant SMT solvers.
• z3 A high-level rust bindings for the Z3 SMT solver from Microsoft Research
• z3-sys Low-level bindings for the Z3 SMT solver from Microsoft Research
• z3_ref A high level interface to the Z3 SMT solver
• z3d Z3 DSL interface for Rust
• boolector Safe high-level bindings for the Boolector SMT solver
• boolector-sys Low-level bindings for the Boolector SMT solver
• smt2utils Libraries and tools for the SMT-LIB-2 standard
  • smt2parser A generic parser for SMT2 commands, as specified by the SMT-LIB-2 standard
  • smt2proxy An experimental binary tool to intercept and pre-process SMT2 commands before they are send to an SMT solver
  • z3tracer An experimental parser for Z3 tracing logs obtained by passing trace=true proof=true to Z3
• good_lp Mixed Integer Linear Programming for Rust, with an user-friendly API. This crate allows modeling LP problems, and lets you solve them with various solvers.
• Axiom Profiler A tool for visualising, analysing and understanding quantifier instantiations made via E-matching in a run of an SMT solver
• [2017][PDF] Counterexample Guided Inductive Optimization based on Satisfiability Modulo Theories

CLI

• structopt Parse command line arguments by defining a struct
• clap A simple to use, efficient, and full-featured Command Line Argument Parser
• pico-args An ultra simple CLI arguments parser
• argh A derive-based argument parser optimized for code size

Configuration

• etcetera A library that aims to allow you to determine the locations of configuration, cache and data files for your application. Existing Rust libraries generally do not give you a choice in terms of which standards/conventions (Etcetera calls these ‘strategies’) they follow. Etcetera, on the other hand, gives you the choice