awesome-rust/README.md

Awesome Rust

A curated list of Rust code and resources, inspired by other awesome lists.

If you want to contribute, please read this.

Table of Contents

• Applications written in Rust
• Development Tools
  • Build system
  • Debugging
  • Embedded
  • FFI
  • IDEs
  • Profiling
  • Testing
• Libraries
  • Astronomy
  • Asynchronous
  • Audio
  • Authentication
  • Bioinformatics
  • Caching
  • Cloud
  • Command-line argument parsing
  • Command-line interface
  • Compression
  • Computation
  • Concurrency
  • Configuration
  • Cryptography
  • Database
  • Data structures
  • Date and time
  • Distributed Systems
  • Email
  • Encoding
  • Filesystem
  • Game development
  • Geospatial
  • Graphics
  • Graph processing
  • GUI
  • Image processing
  • Logging
  • Machine learning
  • Markup language
  • Mobile
  • Network programming
  • Parser
  • Platform specific
  • Template engine
  • Text processing
  • Text search
  • Virtualization
  • Web programming
• Resources
• License

Applications written in Rust

See also Friends of Rust (organizations running Rust in production).

• andschwa/rust-genetic-algorithm — a genetic algorithm for academic benchmark problems

• azerupi/mdBook — a command line utility to create books from markdown files

• bluejekyll/trust-dns — a DNS-server

• ivanceras/curtain — a database administration tool for postgresql

• darrint/device-blocker — Limit screen time to children's various mobile devices by blocking internet access on the family Wifi router.

• dlecan/generic-dns-update — a tool to update DNS zonefiles with your IP address

• Factotum — A system to programmatically run data pipelines

• Fractalide — Simple Rust Microservices

• imjacobclark/Herd — an experimental HTTP load testing application

• jedisct1/flowgger — a fast, simple and lightweight data collector

• jwilm/alacritty — a cross-platform, GPU enhanced terminal emulator

• kbknapp/docli — a command line utility for managing DigitalOcean infrastructure

• MaidSafe — a decentralized platform.

• notty — an experimental project to bring new features to the command-line

• qmx/limonite — static blog/website generator

• Sandstorm Collections App

• Servo — a prototype web browser engine

• Parity — Fast, light, and robust Ethereum implementation

• Audio

  • indiscipline/zrtstr — a command line utility for checking if stereo wav files are faux-stereo (i.e. have identical channels) and converting such files to mono.

• Database

  • pingcap/tikv — a distributed KV database in Rust
  • seppo0010/rsedis — a Redis reimplementation in Rust

• Emulators [emulator]

  • Commodore 64
    • kondrak/rust64 —
  • Gameboy
    • Gekkio/mooneye-gb —
    • mvdnes/rboy —
    • NivenT/RGB —
  • NES
    • iamsix/oxidenes —
    • koute/pinky —
    • pcwalton/sprocketnes —
  • Playstation
    • simias/rustation —
  • ZX Spectrum
    • pacmancoder/rustzx —

• Games, see also Games Made With Piston.

  • lifthrasiir/angolmois-rust — a minimalistic music video game which supports the BMS format
  • swatteau/sokoban-rs — a Sokoban implementation
  • Zone of Control — a turn-based hexagonal strategy game
  • rhex — hexagonal ascii roguelike
  • citybound - The city sim you deserve

• Graphics

  • ivanceras/svgbobrus — converts ASCII diagrams into SVG graphics
  • RazrFalcon/svgcleaner — tidies SVG graphics
  • Twinklebear/tray_rust — a ray tracer

• Operating systems, see also A comparison of operating systems written in Rust

  • redox-os/redox —
  • thepowersgang/rust_os —

• System tools

  • Aaronepower/tokei — counts the lines of code
  • buster/rrun — a command launcher for Linux, similar to gmrun
  • cristianoliveira/funzzy — a configurable filesystem watcher inspired by entr
  • derniercri/snatch — a download accelerator
  • mmstick/parallel — a command-line CPU load balancer
  • mmstick/systemd-manager — a systemd service manager written in Rust using GTK-rs.
  • mmstick/tv-renamer — a tv series renaming application with an optional GTK3 frontend.
  • ogham/exa — a replacement for 'ls'
  • uutils/coreutils — a cross-platform Rust rewrite of the GNU coreutils

• Text editors

  • gchp/iota — a simple text editor
  • xi-editor — a modern editor with a backend written in Rust.

• Text processing

  • BurntSushi/ripgrep — combines the usability of The Silver Searcher with the raw speed of grep
  • BurntSushi/xsv — a fast CSV command line tool (slicing, indexing, selecting, searching, sampling, etc.)

• Virtualization

  • tailhook/vagga — a containerization tool without daemons

• Window Managers

  • Immington-Industries/Way Cooler - a customizable tiling window manager

Development tools

• Clippy [clippy] — Rust lints
  • Clippy Service
• clog-tool/clog-cli — generates a changelog from git metadata (conventional changelog)
• dan-t/rusty-tags — create ctags/etags for a cargo project and all of its dependencies
• frewsxcv/crate-deps — generates images of dependency graphs for crates hosted on crates.io
• git-journal — The Git Commit Message and Changelog Generation Framework
• killercup/rustfix — automatically applies the suggestions made by rustc
• Racer — code completion for Rust
• rustfmt — a Rust code formatter
• Rustup — the Rust toolchain installer
• Rust Language Server — a server that runs in the background, providing IDEs, editors, and other tools with information about Rust programs
• rst — the requirements tracking tool made for developers
• semantic-rs — automatic crate publishing

Build system

• Cargo — the Rust package manager
  • rsolomo/cargo-check [cargo-check] — a wrapper around cargo rustc -- -Zno-trans which can be helpful for running a faster compile if you only need correctness checks
  • kbknapp/cargo-count [cargo-count] — lists source code counts and details about cargo projects, including unsafe statistics
  • pwoolcoc/cargo-do [cargo-do] — run multiple cargo commands in a row
  • maxsnew/cargo-dot — generate graphs of a Cargo project's dependencies
  • killercup/cargo-edit [cargo-edit] — allows you to add and list dependencies by reading/writing to your Cargo.toml file from the command line
  • kbknapp/cargo-graph [cargo-graph] — updated fork of cargo-dot with additional features
  • imp/cargo-info [cargo-info] — queries crates.io for crates details from command line
  • regexident/cargo-modules [cargo-modules] — A cargo plugin for showing a tree-like overview of a crate's modules.
  • imp/cargo-multi [cargo-multi] — runs specified cargo command on multiple crates
  • kbknapp/cargo-outdated [cargo-outdated] — displays when newer versions of Rust dependencies are available, or out of date
  • sunng87/cargo-release [cargo-release] — tool for releasing git-managed cargo project, build, tag, publish, doc and push
  • DanielKeep/cargo-script [cargo-script] — lets people quickly and easily run Rust "scripts" which can make use of Cargo's package ecosystem
  • passcod/cargo-watch [cargo-watch] — utility for cargo to compile projects when sources change
  • BurntSushi/cargo-benchcmp [cargo-benchcmp] — utility to compare Rust micro-benchmarks
• CMake
  • SiegeLord/RustCMake — an example project showing usage of CMake with Rust

Debugging

• GDB
  • rust-gdb
• LLDB
  • lldb_batchmode.py — allows to use LLDB in a way similar to GDB's batch mode.
• rr
  • rr — rr is a lightweight tool for recording and replaying execution of applications

Embedded

Rust Embedded

• Cross compiling
  • japaric/rust-cross — everything you need to know about cross compiling Rust programs
  • japaric/xargo — effortless cross compilation of Rust programs to custom bare-metal targets like ARM Cortex-M
• Raspberry Pi
  • Ogeon/rust-on-raspberry-pi — instructions for how to cross compile Rust projects for the Raspberry Pi .

FFI

See also Foreign Function Interface, The Rust FFI Omnibus (a collection of examples of using code written in Rust from other languages) and FFI examples written in Rust.

• C
  • Sean1708/rusty-cheddar — generates C header files from Rust source files
• C++
  • servo/rust-bindgen — a Rust bindings generator
• Erlang
  • hansihe/Rustler — safe Rust bridge for creating Erlang NIF functions
• Haskell
  • mgattozzi/curryrs — Bridge the gap between Haskell and Rust
  • mgattozzi/haskellrs — Rust in Haskell FFI Example
  • mgattozzi/rushs — Haskell in Rust FFI Example
• Java
  • drrb/java-rust-example — use Rust from Java
  • GravityScore/RustJNI — use Java from Rust
  • kud1ing/rucaja [rucaja] — use Java from Rust
  • prevoty/jni-rs [jni] — use Rust from Java
  • sfackler/rust-jni-sys [jni-sys] — Rust definitions corresponding to jni.h
• Lua
  • jcmoyer/rust-lua53 — Lua 5.3 bindings for Rust
  • kballard/rust-lua — Safe Rust bindings to Lua 5.1
  • tickbh/td_rlua — Zero-cost high-level lua 5.3 wrapper for Rust
  • tomaka/hlua — Rust library to interface with Lua
• mruby
  • anima-engine/mrusty — mruby safe bindings for Rust
• Node.js
  • rustbridge/neon — use Rust from Node.js
• Objective-C
  • SSheldon/rust-objc — Objective-C Runtime bindings and wrapper for Rust
• Python
  • dgrunwald/rust-cpython — Python bindings
  • lukemetz/rustpy — Python bindings
• R
  • rustr/rustr — use Rust from R, and use R in Rust
• Ruby
  • d-unseductable/ruru — native Ruby extensions written in Rust
  • rustbridge/helix — write Ruby classes in Rust

IDEs

See also http://areweideyet.com/ and Rust and IDEs.

• Atom
  • zargony/atom-language-rust
• Eclipse
  • RustDT —
• NetBeans
  • drrb/rust-netbeans
• IntelliJ
  • intellij-rust/intellij-rust —
  • intellij-rust/intellij-toml — basic Toml support
  • JustSid/AfterglowIntelliJ — custom icons
• Ride —
• SolidOak — a simple IDE for Rust, based on GTK+ and Neovim
• Vim — the ubiquitous text editor
  • rust.vim — provides file detection, syntax highlighting, formatting, Syntastic integration, and more.
  • vim-cargo — command bindings to quickly run cargo stuff from vim.
  • vim-racer — allows vim to use Racer for Rust code completion and navigation.
• Visual Studio
  • PistonDevelopers/VisualRust — a Visual Studio extension for Rust
• Visual Studio Code
  • saviorisdead/RustyCode
  • KalitaAlexey/vscode-rust - a fork of RustyCode

Pattern Recognition

• sfikas/rusteval — A tool used to evaluate the output of retrieval algorithms

Profiling

• ellisonch/rust-stopwatch — a stopwatch library
• FlameGraphs
  • mrhooray/torch — generates FlameGraphs based on DWARF Debug Info
  • TyOverby/flame —

Testing

[testing]

• BurntSushi/quickcheck [quickcheck] — a Rust implementation of QuickCheck
• farcaller/shiny — a fancy syntax similar to Ruby's Rspec or Objective-C' kiwi
• frewsxcv/afl.rs — a Rust fuzzer, using AFL
• reem/stainless [stainless] — Organized, flexible testing framework

Libraries

Astronomy

[astronomy]

• saurvs/astro-rust — astronomy for Rust
• mindriot101/rust-fitsio [fitsio] — fits interface library wrapping cfitsio
• flosse/rust-sun — A rust port of the JS library suncalc

Asynchronous

• zonyitoo/coio-rs — a coroutine I/O library with a working-stealing scheduler
• dpc/mioco — Scalable, coroutine-based, asynchronous IO handling library
• alexcrichton/futures-rs — Zero-cost futures in Rust
• carllerche/mio — MIO is a lightweight IO library for Rust with a focus on adding as little overhead as possible over the OS abstractions

Audio

[audio]

• GuillaumeGomez/rust-fmod — FMOD bindings
• jhasse/ears — a simple library to play Sounds and Musics, on top of OpenAL and libsndfile
• jpernst/openal-rs — OpenAL 1.1 bindings
• musitdev/portmidi-rs — PortMidi bindings
• ruuda/hound [Hound] — A WAV encoding and decoding library
• RustAudio
  • RustAudio/rust-portaudio — PortAudio bindings

Authentication

• keats/rust-jwt — JSON Web Token lib in rust
• hngiang/rust-accountkit — An implementation Facebook AccountKit for Rust

Bioinformatics

• Rust-Bio — bioinformatics libraries in Rust.

Caching

• jaysonsantos/bmemcached-rs — Memcached library written in pure rust

Concurrency

• aturon/crossbeam – Support for parallelism and low-level concurrency in Rust
• nikomatsakis/rayon – A data parallelism library for Rust
• rustcc/coroutine-rs – Coroutine Library in Rust
• zonyitoo/coio-rs – Coroutine I/O for Rust

Cloud

• AWS [aws]
  • rusoto/rusoto —
• DigitalOcean
  • kbknapp/doapi — DigitalOcean v2 API bindings

Command-line argument parsing

• docopt/docopt.rs — a Rust implementation of DocOpt
• kbknapp/clap-rs — a simple to use, full featured command-line argument parser

Command-line interface

• kkawakam/rustyline — Readline Implementation in Rust
• srijs/rust-copperline — pure-Rust Command Line Editing Library

Compression

• brotli
  • ende76/brotli-rs — implementation of Brotli compression
  • dropbox/rust-brotli — Brotli decompressor in Rust that optionally avoids the stdlib
• bzip2
  • alexcrichton/bzip2-rs — libbz2 bindings
• miniz
  • alexcrichton/flate2-rs — miniz bindings
• snappy
  • JeffBelgum/rust-snappy — snappy bindings
• tar
  • alexcrichton/tar-rs — tar archive reading/writing in Rust
• zip
  • slackito/zip — read and write ZIP archives

Computation

• BLAS [blas]
  • mikkyang/rust-blas — BLAS bindings
  • stainless-steel/blas — BLAS bindings
• GMP
  • thestinger/rust-gmp — libgmp bindings
• GSL
  • GuillaumeGomez/rust-GSL — GSL bindings
• LAPACK
  • stainless-steel/lapack — LAPACK bindings
• Parallel
  • arrayfire/arrayfire-rust — Arrayfire bindings
  • autumnai/collenchyma — An extensible, pluggable, backend-agnostic framework for parallel, high-performance computations on CUDA, OpenCL and common host CPU.
  • luqmana/rust-opencl — OpenCL bindings
• Scirust
  • indigits/scirust — scientific computing library in Rust
• Statrs
  • boxtown/statrs — Robust statistical computation library in Rust
• Rustimization [rustimization]
  • noshu/rustimization — A rust optimization library which includes L-BFGS-B and Conjugate Gradient algorithm
• L-BFGS-B [lbfgsb]
  • noshu/lbfgsb-sys — Rust binding of fortran L-BFGS-B subroutine
• Conjugate Gradient [CG+]
  • noshu/cg-sys — Rust binding of fortran CG+ subroutine

Configuration

• mehcode/config-rs [config] — Layered configuration system for Rust applications (with strong support for 12-factor applications).

Cryptography

[crypto, cryptography]

• briansmith/ring — Safe, fast, small crypto using Rust and BoringSSL's cryptography primitives.
• briansmith/webpki — Web PKI TLS X.509 certificate validation in Rust.
• ctz/rustls — a Rust implementation of TLS
• DaGenix/rust-crypto — cryptographic algorithms in Rust
• dnaq/sodiumoxide — libsodium bindings
• klutzy/suruga — a Rust implementation of TLS 1.2
• libOctavo/octavo — Modular hash and crypto library in Rust
• sfackler/rust-native-tls — Bindings for native TLS libraries
• sfackler/rust-openssl — OpenSSL bindings
• sfackler/rust-security-framework — Bindings for Security Framework (OSX native crypto)
• steffengy/schannel-rs — Bindings for Schannel (Windows native TLS)
• RNCryptor/rncryptor-rs — Pure Rust implementation of the RNCryptor AES file format

Database

[database]

• sfackler/r2d2 — generic connection pool
• NoSQL [nosql]
  • Cassandra [cassandra, cql]
    • AlexPikalov/cdrs [cdrs] — native client written in Rust
    • tupshin/cassandra-rs — bindings to the C++ client
  • CouchDB [couchdb]
    • chill-rs/chill [couchdb] — a Rust client for the CouchDB REST API
  • Elasticsearch [elasticsearch]
    • benashford/rs-es [rs-es] — a Rust client for the Elastic REST API
    • elastic-rs/elastic-hyper [elastic_hyper] — a lightweight implementation of the Elasticsearch API based on Hyper
  • etcd
    • jimmycuadra/rust-etcd [etcd] — A client library for CoreOS's etcd.
  • ForestDB
    • vhbit/sherwood — ForestDB bindings
  • LevelDB
    • skade/leveldb — LevelDB bindings
  • LMDB [lmdb]
    • vhbit/lmdb-rs [lmdb-rs] — LMDB bindings
  • MongoDB [mongodb]
    • mongodb-labs/mongo-rust-driver-prototype [mongodb] — MongoDB bindings
  • Neo4j [cypher, neo4j]
  • Redis [redis]
    • mitsuhiko/redis-rs — Redis library in Rust
  • RocksDB
    • spacejam/rust-rocksdb — RocksDB bindings
  • UnQLite
    • zitsen/unqlite.rs — UnQLite bindings
  • ZooKeeper
    • bonifaido/rust-zookeeper [zookeeper] — A client library for Apache ZooKeeper.
• SQL [sql]
  • Microsoft SQL
    • steffengy/tiberius —
  • MySql [mysql]
    • AgilData/mysql-proxy-rs — a MySQL Proxy
    • blackbeam/mysql_async [mysql_async] — asyncronous Rust Mysql driver based on Tokio.
    • blackbeam/rust-mysql-simple [mysql] — a native MySql client
• ORM [orm]
  • deuterium-orm/deuterium — an SQL query builder for Rust
  • diesel-rs/diesel — an ORM and Query builder for Rust
  • ivanceras/rustorm — an ORM for Rust
• PostgreSql [postgres, postgresql]
  • sfackler/rust-postgres [postgres] — a native PostgreSQL client
• Sqlite [sqlite]
  • dckc/rust-sqlite3 — Sqlite3 bindings
  • jgallagher/rusqlite — Sqlite3 bindings

Data structures

• bluss/rust-itertools —
• contain-rs — Extension of Rust's std::collections
• fizyk20/generic-array – a hack to allow for arrays sized by typenums
• Nemo157/roaring-rs – Roaring Bitmaps in Rust
• reem/rust-typemap —
• serde-rs/serde — a framework to generically serialize Rust data structures

Date and time

[date, time]

• lifthrasiir/rust-chrono —
• yaa110/rust-persian-calendar —

Distributed Systems

• Apache Kafka
  • spicavigo/kafka-rust —
• Beanstalkd
  • schickling/rust-beanstalkd — Beanstalkd bindings
• HDFS
  • hyunsik/hdfs-rs — libhdfs bindings

Email

[email]

• gsquire/sendgrid-rs — unofficial Rust library for SendGrid API
• lettre/lettre — an SMTP-library for Rust
• staktrace/mailparse [mailparse] — a library for parsing real-world email files

Encoding

[encoding]

• ASN.1
  • alex/rust-asn1 — a Rust ASN.1 (DER) serializer
• Bencode
  • arjantop/rust-bencode — Bencode implementation in Rust
• Binary
  • arcnmx/nue — I/O and binary data encoding for Rust
  • TyOverby/bincode — a binary encoder/decoder in Rust
• BSON
  • zonyitoo/bson-rs —
• Byte swapping
  • BurntSushi/byteorder — Supports big-endian, little-endian and native byte orders
• Cap'n Proto
  • dwrensha/capnproto-rust —
• CBOR
  • BurntSushi/rust-cbor — Supports JSON conversion and type-based encoding/decoding
• Character Encoding
  • lifthrasiir/rust-encoding —
• CRC
  • mrhooray/crc-rs —
• CSV
  • BurntSushi/rust-csv —
• HTML
  • servo/html5ever — High-performance browser-grade HTML5 parser
  • veddan/rust-htmlescape — encoding/decoding HTML entities
• JSON
  • serde-rs/json [serde_json] — JSON support for Serde framework
  • maciejhirsz/json-rust [json] — JSON implementation in Rust
• Jsonnet
  • Qihoo360/rust-jsonnet —
• MsgPack
  • mneumann/rust-msgpack —
  • 3Hren/msgpack-rust — a pure Rust low/high level MessagePack implementation
• ProtocolBuffers
  • stepancheg/rust-protobuf —
• RON (Rusty Object Notation)
  • kvark/ron —
• Tnetstring
  • erickt/rust-tnetstring —
• TOML
  • alexcrichton/toml-rs —
• XML
  • Florob/RustyXML — an XML parser written in Rust
  • shepmaster/sxd-document — An XML library in Rust
  • shepmaster/sxd-xpath — An XPath library in Rust
  • netvl/xml-rs — a streaming XML library
• YAML
  • chyh1990/yaml-rust — The missing YAML 1.2 implementation for Rust.
  • dtolnay/serde-yaml [serde_yaml] — YAML support for Serde framework
  • kimhyunkang/libyaml-rust — libyaml bindings

Filesystem

[filesystem]

• Temporary Files
  • rust-lang-nursery/tempdir — temporary directory library
  • Stebalien/tempfile — temporary file library
  • Stebalien/xattr [xattr] — list and manipulate unix extended file attributes

Game development

• Allegro
  • SiegeLord/RustAllegro — Allegro 5 bindings
• Challonge
  • vityafx/challonge-rs [challonge] — Client library for the Challonge REST API. Helps to organize tournaments.
• Corange
  • lucidscape/corange-rs — Corange bindings
• Entity-Component Systems (ECS)
  • slide-rs/specs — Specs Parallel ECS
• Game Engines
  • Amethyst — Data-oriented game engine
  • Piston —
• SDL [sdl]
  • brson/rust-sdl — SDL1 bindings
  • AngryLawyer/rust-sdl2 — SDL2 bindings
• SFML
  • jeremyletang/rust-sfml — SFML bindings
• Voxlap
  • bbodi/rust-voxlap — Voxlap bindings

Geospatial

[geo, gis]

• Georust — geospatial tools and libraries written in Rust

Graphics

[graphics]

• gfx-rs/gfx — A high-performance, bindless graphics API for Rust.
• Font
  • dylanede/rusttype — a pure Rust alternative to libraries like FreeType
• OpenGL [opengl]
  • brendanzab/gl-rs —
  • PistonDevelopers/glfw-rs —
  • tomaka/glium — safe OpenGL wrapper for the Rust language.
  • tomaka/glutin — Rust alternative to GLFW
• PDF
  • kaj/rust-pdf —
• Vulkan [vulkan]
  • tomaka/vulkano [vulkano] —

Graph processing

• kud1ing/tinkerpop-rs — an example how to use Apache TinkerPop from Rust

GUI

[gui]

• PistonDevelopers/conrod — An easy-to-use, immediate-mode, 2D GUI library written entirely in Rust
• Cocoa
  • kylewlacy/sorbet-cocoa —
  • servo/cocoa-rs
• gyscos/Cursive [cursive] —
• GTK+ [gtk]
  • gtk-rs/gtk — GTK+ bindings
• ImGui
  • imgui-rs — Rust bindings for ImGui
• IUP
  • dcampbell24/iup-rust — IUP bindings
  • Kiss-ui — a simple UI framework built on IUP
• libui
  • pcwalton/libui-rs — libui bindings
• ncurses [ncurses]
  • jeaye/ncurses-rs — ncurses bindings
• saurvs/nfd-rs — Open native UI file dialogs in Linux, OS X and Windows
• Qt
  • cyndis/qmlrs — QtQuick bindings
  • kitech/qt.rs — Qt5 bindings
  • rust-qt —
  • [White-Oak/qml-rust] (https://github.com/White-Oak/qml-rust) — QML bindings.
• Sciter
  • pravic/rust-sciter — Sciter bindings
• Termbox
  • gchp/rustbox — a Rust implementation of Termbox

Image processing

• chyh1990/imageproc — An advanced image processing library for Rust.
• cybergeek94/img-hash — Perceptual image hashing and comparison for equality and similarity.
• PistonDevelopers/image — Basic imaging processing functions and methods for converting to and from image formats

Logging

[log]

• rust-lang-nursery/log — Logging implementation for Rust
• slog-rs/slog — Structured, composable logging for Rust
• sfackler/log4rs — highly configurable logging framework modeled after Java's Logback and log4j libraries

Machine learning

[machine learning]

See also About Rust’s Machine Learning Community.

• AtheMathmo/rusty-machine — Machine learning library for Rust
• autumnai/leaf — Open Machine Intelligence framework.
• tensorflow/rust — Rust language bindings for TensorFlow.
• maciejkula/rustlearn — Machine learning crate for Rust.

Markup language

• CommonMark
  • google/pulldown-cmark — CommonMark parser in Rust

Mobile

Geal/rust_on_mobile

• Android
  • tomaka/android-rs-glue — glue between Rust and Android
• iOS
  • TimNN/cargo-lipo — a cargo lipo subcommand which automatically creates a universal library for use with your iOS application.
  • vhbit/ObjCrust — using Rust to create an iOS static library
• Pebble
  • andars/pebble.rs — a crate that allows Rust to be used to develop Pebble applications.

Network programming

• FTP
  • mattnenterprise/rust-ftp — an FTP client for Rust
• Low level
  • libpnet/libpnet — a cross-platform, low level networking
  • tokio-rs/tokio — a network application framework for rapid development and highly scalable production deployments of clients and servers.
  • dylanmckay/protocol — Custom TCP/UDP protocol definitions
• NanoMsg
  • thehydroimpulse/nanomsg.rs — nanomsg bindings
• NNTP
  • mattnenterprise/rust-nntp — an NNTP client for Rust
• POP3
  • mattnenterprise/rust-pop3 — a POP3 client for Rust
• SSH
  • alexcrichton/ssh2-rs — libssh2 bindings
  • Thrussh — an SSH library written from scratch in Rust, backed by libsodium
• Stomp
  • zslayton/stomp-rs — a STOMP 1.2 client implementation in Rust
• uTP
  • meqif/rust-utp — a uTP (Micro Transport Protocol) library for Rust.
• ZeroMQ
  • erickt/rust-zmq — ZeroMQ bindings

Parser

• dragostis/pest — Elegant, efficient grammars [] (https://travis-ci.org/dragostis/pest)
• Geal/nom — parser combinator library
• ivanceras/inquerest — an URL parameter parser for rest filter inquiry
• kevinmehall/rust-peg — Parsing Expression Grammar (PEG) parser generator
• m4rw3r/chomp – A fast monadic-style parser combinator
• Marwes/combine — parser combinator library
• nikomatsakis/lalrpop — LR(1) parser generator for Rust
• nrc/zero — zero-allocation parsing of binary data
• ptal/oak — a typed PEG parser generator (compiler plugin)
• rustless/queryst — a query string parsing library for Rust inspired by https://github.com/ljharb/qs

Platform specific

• Linux
  • hannobraun/inotify-rs — inotify bindings
• Unix-like
  • nix-rust/nix — Unix-like API bindings
  • zargony/rust-fuse — FUSE bindings
• Windows
  • retep998/winapi-rs — Windows API bindings

Template engine

• Handlebars
  • sunng87/handlebars-rust — Handlebars template engine with inheritance, custom helper support.
• HTML
  • lfairy/maud — compile-time HTML templates
  • Stebalien/horrorshow-rs — compile-time HTML templates
  • kaj/ructe — HTML template system for Rust
  • Keats/tera — template engine based on Jinja2 and the Django template language.
• Mustache
  • rustache/rustache —
• tailhook/marafet — Compiler for Jade-like template language to cito.js-based virtual dom

Text processing

• BurntSushi/suffix — Linear time suffix array construction (with Unicode support)
• BurntSushi/tabwriter — Elastic tab stops (i.e., text column alignment)
• pwoolcoc/ngrams — Construct n-grams from arbitrary iterators
• rust-lang-nursery/regex — Regular expressions (RE2 style)

Text search

• BurntSushi/fst [fst] —
• JDemler/perlin [perlin] —
• tantivy-search/tantivy [tantivy] —

Virtualization

• beneills/quantum — Advanced Rust quantum computer simulator
• ekse/unicorn-rs — Rust bindings for the unicorn CPU emulator
• saurvs/hypervisor-rs — Hardware-accelerated virtualization on OS X

Web programming

See also Rust web framework comparison.

• Deployment
  • Docker
    • emk/rust-musl-builder — Docker images for compiling static Rust binaries using musl-libc and musl-gcc, with static versions of useful C libraries
  • Google App Engine
    • DenisKolodin/rust-app-engine — App Engine Rust boilerplate
  • Heroku
    • emk/heroku-buildpack-rust — a buildpack for Rust applications on Heroku
• HTTP Client
  • alexcrichton/curl-rust — libcurl bindings
  • hyperium/hyper — an HTTP implementation
  • seanmonstar/reqwest — an ergonomic HTTP Client for Rust.
• HTTP Server
  • fengsp/pencil —
  • hyperium/hyper — an HTTP implementation
  • Iron — a middleware-based server framework
    • sunng87/handlebars-iron — Handlebars-rust as an Iron web framework middleware.
  • Nickel — inspired by Express
  • Ogeon/rustful — a RESTful web framework for Rust
  • Rocket — Rocket is web framework for Rust (nightly) with a focus on ease-of-use, expressability, and speed
  • Rustless — a REST-like API micro-framework inspired by Grape and Hyper
  • tiny-http — Low level HTTP server library
  • tomaka/rouille — Web framework in Rust
  • sappworks/sapper — A lightweight web framework built on async hyper, implemented in Rust language.
• WebSocket
  • cyderize/rust-websocket — a framework for dealing with WebSocket connections (both clients and servers)
  • vityafx/urlshortener-rs [urlshortener] — A very simple urlshortener library for Rust.
  • housleyjk/ws-rs — lightweight, event-driven WebSockets for Rust

Resources

• Benchmarks
  • TeXitoi/benchmarksgame-rs — Rust implementations for the The Computer Language Benchmarks Game
• Decks & Presentations
  • Learning systems programming with Rust — Presented by Julia Evans @ Rustconf 2016.
• Learning
  • exercism.io — programming exercises that help you learn new concepts in Rust.
  • Learning Rust With Entirely Too Many Linked Lists — in-depth exploration of Rust's memory management rules, through implementing a few different types of list structures.
  • Rust by Example
  • rust-learning — a collection of useful resources to learn Rust
  • Rustlings — small exercises to get you used to reading and writing Rust code
  • stdx - Learn these crates first as an extension to std
• Podcasts
  • New Rustacean — a podcast about learning Rust
  • Rusty Radio — covering the rust ecosystem
• RustCamp 2015 Talks
• Rust Design Patterns
• Rust Guidelines
• RustBooks — list of RustBooks

License