Awesome Rust

A curated list of Rust code and resources.

If you want to contribute, please read this.

Table of contents

• Applications
  • Audio
  • Cryptocurrencies
  • Database
  • Emulators
  • Games
  • Graphics
  • Industrial automation
  • Operating systems
  • Productivity
  • Security tools
  • System tools
  • Text editors
  • Text processing
  • Utilities
  • Video
  • Virtualization
  • Window managers
  • Web
  • Web Servers
• Development tools
  • Build system
  • Debugging
  • Deployment
  • Embedded
  • FFI
  • IDEs
  • Pattern recognition
  • Profiling
  • Static analysis
  • Testing
  • Transpiling
• Libraries
  • Artificial Intelligence
    • Genetic algorithms
    • Machine learning
  • Astronomy
  • Asynchronous
  • Audio
  • Authentication
  • Bioinformatics
  • Caching
  • Cloud
  • Command-line
  • Compression
  • Computation
  • Concurrency
  • Configuration
  • Cryptography
  • Database
  • Data processing
  • Data structures
  • Data visualization
  • Date and time
  • Distributed systems
  • Email
  • Encoding
  • Filesystem
  • Game development
  • Geospatial
  • Graphics
  • Graph processing
  • GUI
  • Image processing
  • Industrial automation
  • Language specification
  • Logging
  • Macro
  • Markup language
  • Mobile
  • Network programming
  • Parser
  • Platform specific
  • Scripting
  • Template engine
  • Text processing
  • Text search
  • Virtualization
  • Web programming
  • Peripherals
• Resources
• License

Applications

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/diwata — a database administration tool for postgresql
• linkerd/linkerd2-proxy - Ultralight service mesh for Kubernetes.
• danielrangel/rsign [rsign] — A simple command-line tool used to generate/sign/verify digital signatures designed to be compatible with Minisign
• 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
• fcsonline/drill — a HTTP load testing application inspired by Ansible syntax
• Fractalide — Simple Rust Microservices
• habitat — An tool created by Chef to build, deploy, and manage applications.
• imjacobclark/Herd — an experimental HTTP load testing application
• intecture/api — an API-driven server management and configuration tool
• 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.
• nicohman/eidolon — a steam and drm-free game registry and launcher for linux and macosx
• notty — A new kind of terminal
• Pijul — a patch-based distributed version control system
• qmx/limonite — static blog/website generator
• Sandstorm Collections App
• Servo — a prototype web browser engine
• Weld — Full fake REST API generator

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.

Cryptocurrencies

• ethaddrgen — Custom Ethereum vanity address generator made in Rust
• coinbase-pro-rs - Coinbase pro client in Rust, supports sync/async/websocket
• polkadot — Heterogeneous multi‑chain technology with pooled security
• parity-ethereum — Fast, light, and robust Ethereum client
• parity-bitcoin — The Parity Bitcoin client
• parity-bridge — Bridge between any two ethereum-based networks
• ArgusObserver/wagu [wagu] — Generate a wallet for any cryptocurrency

Database

• Mentat - Project Mentat is a persistent, embedded knowledge base. It draws heavily on DataScript and Datomic. Mentat is intended to be a flexible relational (not key-value, not document-oriented) store that makes it easy to describe, grow, and reuse your domain schema.
• PumpkinDB — an event sourcing database engine
• seppo0010/rsedis — a Redis reimplementation in Rust
• ParityDB - Fast and reliable database, optimised for read operation
• tikv — a distributed KV database in Rust

Emulators

See also crates matching keyword '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 —
• Virtual Boy
  • emu-rs/rustual-boy —
• Emulator Development tools
  • SNES
    • ioncodes/snesutilities — ROM analyser/extractor

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
• ozkriff/zemeroth — a small 2D turn-based hexagonal strategy game
• rsaarelm/magog - A roguelike game in Rust
• cristicbz/rust-doom - A renderer for Doom, may progress to being a playable game
• Thinkofname/rust-quake - Quake map renderer in Rust

Graphics

• Limeth/euclider — a real-time 4D CPU ray tracer
• ivanceras/svgbob — converts ASCII diagrams into SVG graphics
• RazrFalcon/svgcleaner — tidies SVG graphics
• Twinklebear/tray_rust — a ray tracer
• Image processing
  • spejss/Image-Processing-CLI-in-Rust — CLI for processing images, generating histograms.

Industrial automation

• slowtec/tokio-modbus - A tokio-based modbus library.
• locka99/opcua - A pure rust OPC UA library.
• BiancoRoyal/modbus-iiot-rust - A pure rust modbus library with no or less dependencies.

Operating systems

See also A comparison of operating systems written in Rust.

• redox-os/redox —
• thepowersgang/rust_os —
• tock/tock — A secure embedded operating system for Cortex-M based microcontrollers
• nebulet/nebulet — A microkernel that implements a WebAssembly "usermode" that runs in Ring 0.

Productivity

• simeg/eureka [eureka] - a CLI tool to input and store your ideas without leaving the terminal

Security tools

• kpcyrd/badtouch — Scriptable network authentication cracker
• kpcyrd/rshijack — tcp connection hijacker, rust rewrite of shijack
• kpcyrd/sniffglue — Secure multithreaded packet sniffer

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
• brocode/fblog — Small command-line JSON Log viewer
• jhspetersson/fselect [fselect] — Find files with SQL-like queries
• k0pernicus/zou — a download accelerator
• lotabout/skim — A fuzzy finder in pure rust
• mmstick/concurr — Alternative to GNU Parallel w/ a client-server architecture
• mmstick/fontfinder — GTK3 application for previewing and installing Google's fonts
• mmstick/parallel — Reimplementation of GNU Parallel
• 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'
• pop-os/debrep — APT repository tool for building and managing an APT repo
• pop-os/popsicle — GTK3 & CLI utility for flashing multiple USB devices in parallel
• pop-os/pop-recovery — Utility for updating the recovery partition on a Pop!_OS install.
• Ralvke/logram — Push log files' updates to Telegram
• redox-os/ion — Next-generation system shell
• sharkdp/bat — A cat(1) clone with wings.
• sharkdp/fd — A simple, fast and user-friendly alternative to find.
• sitkevij/hex — A colorized hexdump terminal utility.
• m4b/bingrep — Greps through binaries from various OSs and architectures, and colors them.
• uutils/coreutils — a cross-platform Rust rewrite of the GNU coreutils
• watchexec — Executes commands in response to file modifications

Text editors

• gchp/iota — a simple text editor
• mathall/rim — Vim-like text editor written in Rust
• Remacs - A community-driven port of Emacs to Rust.
• xi-editor — a modern editor with a backend written in Rust.
• xray — An experimental next-generation Electron-based text editor.

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.)
• whitfin/runiq - an efficient way to filter duplicate lines from unsorted input.

Utilities

• brycx/checkpwn - A Have I Been Pwned (HIBP) command-line utility tool that lets you easily check for compromised accounts and passwords.
• evansmurithi/cloak - A Command Line OTP (One Time Password) Authenticator application.
• myfreeweb/freepass — The free password manager for power users.
• arthrp/quick-skeleton — Project scaffolding tool, similar to Yeoman and Slush.
• yaa110/rubigo — Golang dependency tool and package manager, written in Rust
• whitfin/s3-meta - A command line tool to gather metadata about your Amazon S3 buckets.
• amar-laksh/workstation - A commandline tool to help you manage your workstation by distancing you from your screen, locking your screen when you aren't there among other things with OPENCV!

Video

• yuvadm/slingr - A simple CLI for streaming media files over a local network to UPnP media renderers

Virtualization

• tailhook/vagga — a containerization tool without daemons

Window managers

• way-cooler/way-cooler — a customizable Wayland compositor (window manager)

Web

• OUISRC/muro — The interest and community for internet .(reddit clone)
• rustlang-cn/ruster — online community in rust for rust community

Web Servers

• thecoshman/http — Host These Things Please - a basic http server for hosting a folder fast and simply

• svenstaro/miniserve — a small, self-contained cross-platform CLI tool that allows you to just grab the binary and serve some file(s) via HTTP
• TheWaWaR/simple-http-server - simple static http server

Development tools

• Clippy [clippy] — Rust lints
• 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
• rust-lang-nursery/rustfix — automatically applies the suggestions made by rustc
• just — A handy command runner for project-specific tasks
• Module Linker — Extension that adds <a> links to references in mod, use and extern crate statements at GitHub.
• ptags — A parallel universal-ctags wrapper for git repository
• 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
• artifact — the design doc tool made for developers
• semantic-rs — automatic crate publishing
• fw — workspace productivity booster

Build system

• Cargo — the Rust package manager
  • BurntSushi/cargo-benchcmp [cargo-benchcmp] — utility to compare Rust micro-benchmarks
  • cardoe/cargo-bitbake [cargo-bitbake] - cargo extension that can generate BitBake recipes utilizing the classes from meta-rust
  • 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
  • mmstick/cargo-deb — generate binary Debian packages
  • pwoolcoc/cargo-do [cargo-do] — run multiple cargo commands in a row
  • maxsnew/cargo-dot — generate graphs of a Cargo project's dependencies
  • cardoe/cargo-ebuild [cargo-ebuild] - cargo extension that can generate ebuilds using the in-tree eclasses
  • killercup/cargo-edit [cargo-edit] — allows you to add and list dependencies by reading/writing to your Cargo.toml file from the command line
  • Ralvke/cargo-find [cargo-find] — Find crates from 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
  • sagiegurari/cargo-make [cargo-make] — Rust task runner and build tool.
  • 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
  • greyblake/cargo-testify [cargo-testify] — watches files changes, runs tests and notifies about the result with friendly OS notification
  • nabijaczleweli/cargo-update [cargo-update] — cargo subcommand for checking and applying updates to installed executables
  • passcod/cargo-watch [cargo-watch] — utility for cargo to compile projects when sources change
• CMake
  • SiegeLord/RustCMake — an example project showing usage of CMake with Rust
• Webpack
  • Ralvke/rust-loader — Webpack Rust loader (wasm)

Debugging

• GDB
  • rust-gdb
  • gdbgui — Browser based frontend for gdb to debug C, C++, Rust, and go.
• LLDB
  • lldb_batchmode.py — allows to use LLDB in a way similar to GDB's batch mode.
  • CodeLLDB — a LLDB extension for Visual Studio Code.
• rr
  • rr — rr is a lightweight tool for recording and replaying execution of applications

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
  • kpcyrd/mini-docker-rust — An example project for very small rust docker images
  • liuchong/docker-rustup — a multiple version (with musl tools) Rust Docker image
  • messense/rust-musl-cross - Docker images for compiling static Rust binaries using musl-cross
  • rust-lang-nursery/docker-rust — the official Rust Docker image
• Google App Engine
  • DenisKolodin/rust-app-engine — App Engine Rust boilerplate
• Heroku
  • emk/heroku-buildpack-rust — a buildpack for Rust applications on Heroku

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
  • rlhunt/cbindgen — generates C header files from Rust source files. Used in Gecko for WebRender
  • Sean1708/rusty-cheddar — generates C header files from Rust source files
• C++
  • rust-lang-nursery/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
  • bennettanderson/rjni — use Java from Rust
  • drrb/java-rust-example — use Rust from Java
  • kud1ing/rucaja [rucaja] — use Java from Rust
  • prevoty/jni-rs [jni] — use Rust from Java
  • rawrasaur/rust-jdbc — uses JDBC from Rust
  • 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
  • neon-bindings/neon — use Rust from Node.js
• Objective-C
  • SSheldon/rust-objc — Objective-C Runtime bindings and wrapper for Rust
• Perl
  • vickenty/mi-rust - Adds support to M::I for building modules with Cargo
  • vickenty/perl-xs - Create Perl XS modules using Rust
• Python
  • getsentry/milksnake - extension for python setuptools that allows you to distribute dynamic linked libraries in Python wheels in the most portable way imaginable.
  • dgrunwald/rust-cpython — Python bindings
  • PyO3/PyO3 — Rust bindings for the Python interpreter
• R
  • rustr/rustr — use Rust from R, and use R in Rust
• Ruby
  • d-unseductable/ruru — native Ruby extensions written in Rust
  • tildeio/helix — write Ruby classes in Rust
• Web Assembly
  • rustwasm/wasm-pack — 📦 ✨ pack up the wasm and publish it to npm!
  • rustwasm/wasm-bindgen — A project for facilitating high-level interactions between wasm modules and JS.

IDEs

See also Are we (I)DE yet? and Rust and IDEs.

• Atom
  • zargony/atom-language-rust
• Eclipse
  • RustDT —
• Emacs
  • rust-mode — Rust Major Mode
  • flycheck-rust — Rust support for Flycheck
  • emacs-racer — Autocompletion (see also company and auto-complete)
  • lsp-rust - Add rls support to lsp-mode
• gnome-builder native support for rust and cargo since Version 3.22.2
• Kakoune
  • ul/kak-lsp — LSP client. Implemented in Rust and supports rls out of the box.
• NetBeans
  • drrb/rust-netbeans
• IntelliJ
  • intellij-rust/intellij-rust —
  • intellij-rust/intellij-toml — basic Toml support
• Ride —
• SolidOak — a simple IDE for Rust, based on GTK+ and Neovim
• Sublime Text
  • rust-lang/rust-enhanced — official Rust package
  • sublimehq/packages — native Sublime support (already installed)
• 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.
  • autozimu/LanguageClient-neovim — LSP client. Implemented in Rust and supports rls out of the box.
• Visual Studio
  • PistonDevelopers/VisualRust — a Visual Studio extension for Rust
• Visual Studio Code
  • rust-lang-nursery/rls-vscode - Rust support for Visual Studio Code
  • CodeLLDB — a LLDB extension
  • crates - crates is an extension for crates.io dependencies.
  • KalitaAlexey/vscode-rust — a fork of RustyCode
  • saviorisdead/RustyCode (unmaintained)

Pattern recognition

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

Profiling

• performancecopilot/hornet — a Performance Co-Pilot memory-mapped values instrumentation library
• ellisonch/rust-stopwatch — a stopwatch library
• FlameGraphs
  • mrhooray/torch — generates FlameGraphs based on DWARF Debug Info
  • TyOverby/flame —

Static analysis

[assert, static]

• nvzqz/static-assertions-rs [static_assertions] Compile-time assertions to ensure that invariants are met

Testing

[testing]

• llogiq/mutagen [mutagen] — A source-level mutation testing framework (nightly only)
• AlKass/polish — Mini Testing/Test-Driven Framework
• altsysrq/proptest [proptest] — property testing framework inspired by the Hypothesis framework for Python
• BurntSushi/quickcheck [quickcheck] — a Rust implementation of QuickCheck
• Mockito [mockito] — HTTP mocking
• utkarshkukreti/speculate.rs [speculate] — An RSpec inspired minimal testing framework for Rust
• rust-fuzz/afl.rs — a Rust fuzzer, using AFL
• trust - A Travis CI and AppVeyor template to test your Rust crate on 5 architectures and publish binary releases of it for Linux, macOS and Windows
• xd009642/tarpaulin [tarpaulin] — A code coverage tool designed for Rust

Transpiling

• immunant/c2rust - C to Rust translator and cross checker built atop Clang/LLVM.
• jameysharp/corrode - A C to Rust translator written in Haskell.

Libraries

Artificial Intelligence

Genetic algorithms

• Martin1887/oxigen — Fast, parallel, extensible and adaptable genetic algorithm library. A example using this library solves the N Queens problem for N = 255 in only few seconds and using less than 1 MB of RAM.
• innoave/genevo — Execute genetic algorithm (GA) simulations in a customizable and extensible way.
• willi-kappler/darwin-rs — This library allows you to write evolutionary algorithms (EA) using the Rust programming language. Written by Willi Kappler, License: MIT - Version 0.4 (2017.06.26).
• m-decoster/RsGenetic — Genetic Algorithm library in Rust. In maintenance mode.
• mneumann/evo-rs — Evolutionary Algorithm Library for Rust. Without changes for 3 years.
• yurytsoy/revonet — Rust implementation of real-coded GA for solving optimization problems and training of neural networks.

Machine learning

[machine learning]

See also About Rust’s Machine Learning Community.

• AtheMathmo/rusty-machine — Machine learning library for Rust
• avinashshenoy97/RusticSOM — Rust library for Self Organising Maps (SOM).
• autumnai/leaf — Open Machine Intelligence framework. . Abandoned project. The most updated fork is spearow/juice.
• tensorflow/rust — Rust language bindings for TensorFlow.
• maciejkula/rustlearn — Machine learning crate for Rust.

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
• TeaEntityLab/fpRust — Monad/MonadIO, Handler, Coroutine/doNotation, Functional Programming features for Rust
• rust-lang-nursery/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/alto — OpenAL 1.1 bindings
• musitdev/portmidi-rs — PortMidi bindings
• ruuda/hound [Hound] — A WAV encoding and decoding library
• tomaka/rodio - A Rust audio playback library
• RustAudio
  • RustAudio/rust-portaudio — PortAudio bindings

Authentication

• hngnaig/rust-accountkit — An implementation Facebook AccountKit for Rust
• Keats/jsonwebtoken — JSON Web Token lib in rust

Bioinformatics

• Rust-Bio — bioinformatics libraries in Rust.

Caching

• jaysonsantos/bmemcached-rs — Memcached library written in pure rust
• jaemk/cached — Simple function caching/memoization
• aisk/rust-memcache - Memcached client library

Concurrency

• crossbeam-rs/crossbeam – Support for parallelism and low-level concurrency in Rust
• pop-os/bus-writer - Generic single-reader, multi-writer
• 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
  • clap-rs [clap] — a simple to use, full featured command-line argument parser
  • docopt/docopt.rs [docopt] — a Rust implementation of DocOpt
  • TeXitoi/structopt [structopt] — parse command line argument by defining a struct
  • killercup/quicli [quicli] — quickly build cool CLI apps in Rust
• Human-centered design
  • rust-clique/human-panic [human-panic] — panic messages for humans
• Line editor
  • srijs/rust-copperline [copperline] — pure-Rust command line editing library
  • MovingtoMars/liner [liner] — a library offering readline-like functionality
  • murarth/linefeed [linefeed] — Configurable, extensible, interactive line reader
  • kkawakam/rustyline [rustyline] — readline implementation in Rust
• Pipeline
  • imp/pager-rs [pager] — pipe your output through an external pager
  • hniksic/rust-subprocess [subprocess] — facilities for interaction with external pipelines
  • oconnor663/duct.rs [duct] — a builder for subprocess pipelines and IO redirection
  • philippkeller/rexpect [rexpect] — automate interactive applications such as ssh, ftp, passwd, etc
• Progress
  • mitsuhiko/indicatif [indicatif] — indicate progress to users
  • a8m/pb [pbr] — console progress bar for Rust
  • FGRibreau/spinners [spinners] — 60+ elegant terminal spinners
• Prompt
  • hashmismatch/terminal_cli.rs [terminal_cli] — build an interactive command prompt
• Style
  • ogham/rust-ansi-term [ansi_term] — control colours and formatting on ANSI terminals
  • LukasKalbertodt/term-painter [term-painter] — cross-platform styled terminal output
  • vitiral/termstyle [termstyle] — build (and test) formatted and styled command line applications
  • SergioBenitez/yansi [yansi] — a dead simple ANSI terminal color painting library
• TUI
  • TimonPost/crossterm [crossterm] — crossplatform terminal library
  • gyscos/Cursive [cursive] — build rich TUI applications
  • ogham/rust-term-grid [term_grid] — Rust library for putting things in a grid
  • ticki/termion [termion] — bindless library for controlling terminals/TTY
  • fdehau/tui-rs [tui] — a TUI library inspired by blessed-contrib and termui
  • BearLibTerminal
    • cfyzium/bearlibterminal [bear-lib-terminal] — BearLibTerminal bindings
  • ncurses
    • jeaye/ncurses-rs [ncurses] — ncurses bindings
    • ihalila/pancurses [pancurses] — curses library, supports linux and windows
  • Termbox
    • gchp/rustbox [rustbox] — bindings to Termbox

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
• gzip
  • carols10cents/zopfli — implementation of the Zopfli compression algorithm for higher quality deflate or zlib compression
• miniz
  • alexcrichton/flate2-rs — miniz bindings
• snappy
  • JeffBelgum/rust-snappy — snappy bindings
• tar
  • alexcrichton/tar-rs — tar archive reading/writing in Rust
• zip
  • mvdnes/zip-rs — read and write ZIP archives

Computation

• BLAS [blas]
  • mikkyang/rust-blas — BLAS bindings
  • stainless-steel/blas — BLAS bindings
• Conjugate Gradient
  • noshu/cg-sys — Rust binding of fortran CG+ subroutine
• GMP
  • fizyk20/rust-gmp — libgmp bindings
• GSL
  • GuillaumeGomez/rust-GSL — GSL bindings
• LAPACK
  • stainless-steel/lapack — LAPACK bindings
• L-BFGS-B
  • noshu/lbfgsb-sys — Rust binding of fortran L-BFGS-B subroutine
• rustsim/nalgebra — low-dimensional linear algebra library
• 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

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.
• brycx/orion - This library aims to provide easy and usable crypto. 'Usable' meaning exposing high-level API's that are easy to use and hard to misuse.
• ctz/rustls — a Rust implementation of TLS
• DaGenix/rust-crypto — cryptographic algorithms in Rust
• dnaq/sodiumoxide — libsodium bindings
• doublify/libblockchain — A Blockchain implementation
• exonum/exonum [exonum] — extensible framework for blockchain projects
• klutzy/suruga — a Rust implementation of TLS 1.2
• libOctavo/octavo — Modular hash and crypto library in Rust
• RustCrypto/hashes - Collection of cryptographic hash functions written in pure Rust
• rustindia/mpw-rs — Pure Rust implementation of the Master Password password manager
• racum/rust-djangohashers — A Rust port of the password primitives used in the Django Project. It doesn't require Django, only hashes and validates passwords according to its style.
• RNCryptor/rncryptor-rs — Pure Rust implementation of the RNCryptor AES file format
• conradkdotcom/rooster [rooster] — Simple password manager to use in your terminal
• 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)
• zebradil/rustotpony — CLI manager of one-time password generators aka Google Authenticator (TOTP)

Database

[database]

• sfackler/r2d2 — generic connection pool
• NoSQL [nosql]
  • Cassandra [cassandra, cql]
    • AlexPikalov/cdrs [cdrs] — native client written in Rust
    • Metaswitch/cassandra-rs — bindings to the DataStax C/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-reqwest [elastic_reqwest] — a lightweight implementation of the Elasticsearch API based on Reqwest
  • etcd
    • jimmycuadra/rust-etcd [etcd] — A client library for CoreOS's etcd.
  • ForestDB
    • vhbit/sherwood — ForestDB bindings
  • InfluxDB
    • panoptix-za/influxdb-rs — asynchronous interface
    • driftluo/InfluxDBClient-rs - Synchronization interface
  • 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
    • rust-rocksdb/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
  • PostgreSql [postgres, postgresql]
    • sfackler/rust-postgres [postgres] — a native PostgreSQL client
  • Sqlite [sqlite]
    • jgallagher/rusqlite — Sqlite3 bindings
• ORM [orm]
  • diesel-rs/diesel — an ORM and Query builder for Rust
  • ivanceras/rustorm — an ORM for Rust

Data processing

• bluss/ndarray — N-dimensional array with array views, multidimensional slicing, and efficient operations
• kernelmachine/utah — Dataframe structure and operations in Rust
• weld-project/weld - High-performance runtime for data analytics applications

Data structures

• bluss/rust-itertools —
• contain-rs — Extension of Rust's std::collections
• danielpclark/array_tool — Array helpers for Rust. Some of the most common methods you would use on Arrays made available on Vectors. Polymorphic implementations for handling most of your use cases.
• fizyk20/generic-array – a hack to allow for arrays sized by typenums
• Nemo157/roaring-rs – Roaring Bitmaps in Rust
• orium/rpds [rpds] — Persistent data structures in Rust.
• garro95/priority-queue[priority-queue] - A priority queue that implements priority changes.
• reem/rust-typemap —
• xfix/enum-map [enum-map] — An optimized map implementation for enums using an array to store values.

Data visualization

• saresend/gust -

Date and time

[date, time]

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

Distributed systems

• Antimony
  • antimonyproject/antimony [antimony] — stream processing / distributed computation platform
• Apache Hadoop
  • whitfin/efflux - Easy Hadoop Streaming and MapReduce interfaces in Rust.
• Apache Kafka
  • fede1024/rust-rdkafka [rdkafka] — librdkafka bindings
  • spicavigo/kafka-rust —
• Beanstalkd
  • schickling/rust-beanstalkd — Beanstalkd bindings
• HDFS
  • hyunsik/hdfs-rs — libhdfs bindings

Email

[email, imap, smtp]

• GildedHonour/atarashii_imap — 新しい (atarashii/new) IMAP client in Rust. It supports plain and secure connections
• 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
  • m4b/goblin [goblin] — cross-platform, zero-copy, and endian-aware binary parsing
• BSON
  • zonyitoo/bson-rs —
• Byte swapping
  • BurntSushi/byteorder — Supports big-endian, little-endian and native byte orders
• Cap'n Proto
  • capnproto/capnproto-rust —
• CBOR
  • BurntSushi/rust-cbor — Supports JSON conversion and type-based encoding/decoding
• Character Encoding
  • hsivonen/encoding_rs [encoding_rs] — A Gecko-oriented implementation of the Encoding Standard in Rust
  • 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
  • pikkr/pikkr [pikkr] — JSON parser which picks up values directly without performing tokenization in Rust
  • serde-rs/json [serde_json] — JSON support for Serde framework
  • maciejhirsz/json-rust [json] — JSON implementation in Rust
• Jsonnet
  • Qihoo360/rust-jsonnet —
• MsgPack
  • 3Hren/msgpack-rust — a pure Rust low/high level MessagePack implementation
• PEM
  • jcreekmore/pem-rs [pem] - a Rust based way to parse and encode PEM-encoded data
• ProtocolBuffers
  • danburkert/prost —
  • stepancheg/rust-protobuf —
• RON (Rusty Object Notation)
  • https://github.com/ron-rs/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
  • vitiral/stfu8 — Sorta Text Format in UTF-8
  • media-io/yaserde — Yet Another Serializer/Deserializer specialized for XML

Filesystem

[filesystem]

• Operations
  • pop-os/dbus-udisks2 -> UDisks2 DBus API
  • pop-os/sys-mount - High level abstraction for the mount / umount2 system calls.
  • vitiral/path_abs — Absolute serializable path types and associated methods.
  • webdesus/fs_extra — expanding opportunities standard library std::fs and std::io
• Temporary Files
  • rust-lang-deprecated/tempdir — temporary directory library
  • Stebalien/tempfile — temporary file library
  • Stebalien/xattr [xattr] — list and manipulate unix extended file attributes
  • zboxfs/zbox [zbox] — Zero-details, privacy-focused embeddable file system.

Game development

See also Are we game yet?

• 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 —
  • ggez - a lightweight game framework for making 2D games with minimum friction
  • Kiss3D - a Keep It Simple, Stupid 3d graphics engine written with Rust
  • Unrust - unrust - A pure rust based (webgl 2.0 / native) game engine
• SDL [sdl]
  • brson/rust-sdl — SDL1 bindings
  • Rust-SDL2/rust-sdl2 — SDL2 bindings
• SFML
  • jeremyletang/rust-sfml — SFML bindings
• Tcod-rs
  • tomassedovic/tcod-rs — Libtcod bindings for Rust.
• Voxlap
  • bbodi/rust-voxlap — Voxlap bindings

Geospatial

[geo, gis]

• vlopes11/geomorph [geomorph] — conversion between UTM, LatLon and MGRS coordinates
• Georust — geospatial tools and libraries written in Rust
• rust-reverse-geocoder — a fast, offline reverse geocoder in Rust, inspired by https://github.com/thampiman/reverse-geocoder

Graphics

[graphics]

• gfx-rs/gfx — A high-performance, bindless graphics API for Rust.
• Font
  • redox-os/rusttype — a pure Rust alternative to libraries like FreeType
• OpenGL [opengl]
  • brendanzab/gl-rs —
  • glium/glium — safe OpenGL wrapper for the Rust language.
  • Kiss3d — draw simple geometric figures and play with them with one-liners
  • PistonDevelopers/glfw-rs —
  • tomaka/glutin — Rust alternative to GLFW
• PDF
  • kaj/rust-pdf —
  • fschutt/printpdf — PDF writing library
  • J-F-Liu/lopdf — PDF document manipulation
• Vulkan [vulkan]
  • vulkano [vulkano] —

Graph processing

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

GUI

[gui]

• autopilot-rs/autopilot-rs - A simple, cross-platform GUI automation library for Rust.
• PistonDevelopers/conrod — An easy-to-use, immediate-mode, 2D GUI library written entirely in Rust
• Cocoa
  • kylewlacy/sorbet-cocoa —
  • servo/core-foundation-rs —
• GTK+ [gtk]
  • gtk-rs/gtk — GTK+ bindings
  • relm — Asynchronous, GTK+-based, GUI library, inspired by Elm
• ImGui
  • imgui-rs — Rust bindings for ImGui
• IUP
  • clear-coat — Clear Coat is a Rust wrapper for the IUP GUI library
  • dcampbell24/iup-rust — IUP bindings
  • Kiss-ui — a simple UI framework built on IUP
• libui
  • pcwalton/libui-rs — libui bindings . Abandoned project. The most updated fork is LeoTindall/libui-rs.
• Nuklear
  • nuklear-rust — Rust bindings for Nuklear
• Qt
  • cyndis/qmlrs — QtQuick bindings
  • kitech/qt.rs — Qt5 bindings
  • Rust Qt Binding Generator — Binding generator hosted by KDE.
  • rust-qt —
  • White-Oak/qml-rust — QML bindings.
• saurvs/nfd-rs — nativefiledialog bindings
• Sciter
  • sciter-sdk/rust-sciter — Sciter bindings

Image processing

• abonander/img_hash — Perceptual image hashing and comparison for equality and similarity.
• chyh1990/imageproc — An advanced image processing library for Rust.
• PistonDevelopers/image — Basic imaging processing functions and methods for converting to and from image formats
• kali/opencv-rust — Rust bindings for OpenCV
• teovoinea/steganography [steganography] — A simple steganography library

Language specification

• shnewto/bnf — A library for parsing Backus–Naur form context-free grammars.

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

Macro

• cute
  • mattgathu/cute - Macro for Python-esque list comprehensions in Rust.
• hado
  • ludat/hado-rs - A little macro for writing haskell-like do expressions without too much ceremony

Markup language

• CommonMark
  • raphlinus/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
• IPNetwork
  • achanda/ipnetwork — A library to work with IP networks in pure 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
  • actix/actix — Actor library for Rust
• 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
• CoAP
  • Covertness/coap-rs — A Constrained Application Protocol(CoAP) library for Rust.

Parser

• 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
• lalrpop/lalrpop — LR(1) parser generator for Rust
• nrc/zero — zero-allocation parsing of binary data
• pest-parser/pest — The Elegant Parser
• 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

Packaging formats

• pop-os/debarchive Library for reading and extracting debian archives

Platform specific

• Linux
  • pop-os/dbus-udisks2 - UDisks2 DBus API
  • pop-os/distinst - Linux distribution installer library
  • inotify-rs/inotify — inotify bindings
  • yaa110/rust-iptables — iptables bindings
• Unix-like
  • nix-rust/nix — Unix-like API bindings
  • zargony/rust-fuse — FUSE bindings
• Windows
  • retep998/winapi-rs — Windows API bindings

Scripting

[scripting]

• PistonDevelopers/dyon — A rusty dynamically typed scripting language
• gluon-lang/gluon — A small, statically-typed, functional programming language
• murarth/ketos — A Lisp dialect functional programming language serving as a scripting and extension language for rust
• JohnBSmith/moss [moss] — A dynamically typed scripting language
• jonathandturner/rhai — A tiny and fast embedded scripting language resembling a combination of JS and Rust

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.
  • djc/askama — template rendering engine based on Jinja
• 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)
• dguo/strsim-rs [strsim-rs] — String similarity metrics
• mgeisler/textwrap [textwrap] — Word wrap text (with support for hyphenation)
• pwoolcoc/ngrams — Construct n-grams from arbitrary iterators
• rust-lang/regex — Regular expressions (RE2 style)
• greyblake/whatlang-rs — Natural language detection library based on trigrams
• yaa110/rake-rs — Multilingual implementation of RAKE algorithm for Rust

Text search

• BurntSushi/fst [fst] —
• CurrySoftware/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 Are we web yet? and Rust web framework comparison.

• Client-side / WASM
  • DenisKolodin/yew [yew] — Rust framework for making client web apps
  • koute/cargo-web [cargo-web] — A Cargo subcommand for the client-side Web
  • koute/stdweb [stdweb] — A standard library for the client-side Web
• HTTP Client
  • alexcrichton/curl-rust — libcurl bindings
  • hyperium/hyper — an HTTP implementation
  • seanmonstar/reqwest — an ergonomic HTTP Client for Rust.
• HTTP Server
  • actix/actix-web — A lightweight async web framework for Rust with websocket support
  • Gotham — A flexible web framework that does not sacrifice safety, security or speed.
  • hyperium/hyper — an HTTP implementation
  • GildedHonour/frank_jwt — JSON Web Token implementation in Rust.
  • 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
  • Saphir — A progressive web framework with low-level control, without the pain.
  • sappworks/sapper — A lightweight web framework built on async hyper, implemented in Rust language.
  • tiny-http — Low level HTTP server library
  • tomaka/rouille — Web framework in Rust
  • danclive/sincere — A micro web framework for Rust(stable) based on hyper and multithreading.
• • oltdaniel/zap - A lightning fast http framework for Rust WebSocket
  • cyderize/rust-websocket — a framework for dealing with WebSocket connections (both clients and servers)
  • housleyjk/ws-rs — lightweight, event-driven WebSockets for Rust
  • snapview/tungstenite-rs — Lightweight stream-based WebSocket implementation for Rust.
  • actix/sockjs — SockJS server for Rust
  • vityafx/urlshortener-rs [urlshortener] — A very simple urlshortener library for Rust.
• Miscellaneous
  • cargonauts — A web framework intended for building maintainable, well-factored web apps.
  • pyros2097/rust-embed — A macro to embed static assets into the rust binary
• Reverse Proxy
  • sozu-proxy/sozu [sozu] - A HTTP reverse proxy.
• Static Site Generators
  • Keats/gutenberg [gutenberg] — An opinionated static site generator with everything built-in.
  • cobalt-org/cobalt.rs - Static site generator written in Rust
  • FuGangqiang/mdblog.rs — Static site generator from markdown files.
  • leven-the-blog/leven [leven] — a simple, parallelized blog generator.

Peripherals

• Serial Port
  • Susurrus/serialport-rs [serialport] - A cross-platform library that provides access to a serial port

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.
  • Shipping a Solid Rust Crate — Presented by Michael Gattozzi @ RustConf 2017
  • Rust: Hack Without Fear! — Presented by Nicholas Matsakis @ C++Now 2018
• Learning
  • Programming Community Curated Resources for Learning Rust - A list of recommended resources voted by the programming community.
  • exercism.io — programming exercises that help you learn new concepts in Rust.
  • Idiomatic Rust — A peer-reviewed collection of articles/talks/repos which teach idiomatic 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 Cookbook — a collection of simple examples that demonstrate good practices to accomplish common programming tasks, using the crates of the Rust ecosystem.
  • Rust in Motion - A video series by Carol Nichols and Jake Goulding (paid)
  • 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
  • University of Pennsylvania's Comp Sci Rust Programming Course
  • Build a language VM
• Podcasts
  • New Rustacean — a podcast about learning Rust
• RustCamp 2015 Talks
• Rust Design Patterns
• Rust Guidelines
• RustBooks — list of RustBooks

License