NEW! Новый релиз 12.0.0 уже доступен! Подробности в Центре заботы
GigaCode
beta
ОбзорЦентр заботыВойти
/
pm
/
awesome-rust

awesome-rust

2

Описание

Избранное13
Следят6
Сообщить о нарушении
1
2
0
README.md
год назад
README.md

awesome-rust

A curated list of Rust code and resources.

Table of contents

Applications

See also Rust - Production(organizations running Rust in production).

  • A/B Street - Transportation planning and traffic simulation software for creating cities friendlier to walking, biking, and public transit.
  • alacritty - A cross-platform, GPU enhanced terminal emulator
  • api - an API-driven server management and configuration tool.
  • Arti — An implementation of Tor, in Rust. (So far, it's a not-very-complete client. But watch this space!)
  • asm-cli-rust - interative assembly shell written in rust.
  • boringtun - A Userspace WireGuard VPN Implementation.
  • datafusion - Apache Arrow DataFusion and Ballista query engines.
  • device-blocker - Limit screen time to children's various mobile devices by blocking internet access on the family Wifi router.
  • dipc - Convert your favorite images and wallpapers with your favorite color palettes/themes.
  • diwata - A database administration tool for postgresql.
  • docli - A command line utility for managing DigitalOcean infrastructure.
  • doh-server - A fast and secure DoH (DNS-over-HTTPS) server written in Rust.
  • drill - A HTTP load testing application inspired by Ansible syntax.
  • eidolon - A steam and drm-free game registry and launcher for linux and macosx.
  • Factotum - A system to programmatically run data pipelines.
  • fend - Arbitrary-precision unit-aware calculator.
  • flowgger - A fast, simple and lightweight data collector.
  • Fractal - Fractal is a Matrix messaging app for GNOME written in Rust. Its interface is optimized for collaboration in large groups, such as free software projects.
  • Fractalide - Simple Rust Microservices
  • generic-dns-update - A tool to update DNS zonefiles with your IP address.
  • habitat - An tool created by Chef to build, deploy, and manage applications.
  • Herd - an experimental HTTP load testing application.
  • innernet - An overlay or private mesh network that uses Wireguard under the hood.
  • kalker - A scientific calculator that supports math-like syntax with user-defined variables, functions, derivation, integration, and complex numbers. Cross platform + WASM support.
  • Kubernetes Dashboard - General-purpose web UI for Kubernetes clusters.
  • kytan - High Performance Peer-to-Peer VPN.
  • s3find-rs - A command line utility to walk an Amazon S3 hierarchy, an analog of find for Amazon S3.
  • rust-genetic-algorithm - A genetic algorithm for academic benchmark problems.
  • linkerd2-proxy - Ultralight service mesh for Kubernetes.
  • limonite - static blog/website generator.
  • MaidSafe - A decentralized platform.
  • mdBook - A command line utility to create books from markdown files.
  • mirrord - Connect your local process and your cloud environment, and run local code in cloud conditions.
  • notty - A new kind of terminal.
  • Pijul - A patch-based distributed version control system.
  • Rio - A hardware-accelerated GPU terminal emulator powered by WebGPU, focusing to run in desktops and browsers.
  • rsign - A simple command-line tool used to generate/sign/verify digital signatures designed to be compatible with Minisign.
  • rx — Vi inspired Modern Pixel Art Editor.
  • Sandstorm Collections App
  • Servo - A prototype web browser engine.
  • shoes - A multi-protocol proxy server.
  • shuttle - A serverless platform built for Rust.
  • Sniffnet - Cross-platform application to monitor your network traffic with ease.
  • SWC - super-fast TypeScript / JavaScript compiler.
  • trust-dns - A DNS-server.
  • wasmer - A safe and fast WebAssembly runtime supporting WASI and Emscripten.
  • Weld - Full fake REST API generator.
  • zellij - A terminal multiplexer (workspace) with batteries included.

Audio and Music

  • enginesound - A GUI and command line application used to procedurally generate semi-realistic engine sounds. Featuring in-depth configuration, variable sample rate and a frequency analysis window.
  • Festival - A local music player/server/client.
  • Glicol - Graph-oriented live coding language written in Rust for collaborative musicking in browsers.
  • Lyriek - A multi-threaded GTK 3 application for fetching the lyrics of the current playing song.
  • mmtc - Minimal mpd terminal client that aims to be simple yet highly configurable.
  • Polaris - A music streaming application.
  • Spotify Player - A Spotify player in the terminal with full feature parity.
  • Spotify TUI - A Spotify client for the terminal written in Rust.
  • Spotifyd - An open source Spotify client running as a UNIX daemon.
  • 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.

Blockchain

  • Akula - Rust Ethereum Execution Layer (EL) Client (WIP).
  • artemis - A simple, modular, and fast framework for writing MEV bots in Rust.
  • beerus - Beerus is a trustless StarkNet Light Client, ⚡blazing fast ⚡ and powered by Rust.
  • bip39-rs - Rust implementation of BIP39.
  • Bitcoin Satoshi's Vision - A Rust library for working with Bitcoin SV.
  • cairo - Cairo is the first Turing-complete language for creating provable programs for general computation. This is also the native language of StarkNet, a ZK-Rollup using STARK proofs
  • cardano-cli - Cardano Command Line Interface (CLI).
  • ChainX - Fully Decentralized Interchain Crypto Asset Management on Polkadot.
  • CITA — A high performance blockchain kernel for enterprise users.
  • coinbase-pro-rs — Coinbase pro client in Rust, supports sync/async/websocket.
  • Diem - Diem’s mission is to enable a simple global currency and financial infrastructure that empowers billions of people.
  • electrumrs - An efficient re-implementation of Electrum Server in Rust.
  • ethabi - Encode and decode smart contract invocations.
  • ethaddrgen - Custom Ethereum vanity address generator made in Rust.
  • ethers-rs - Complete Ethereum & Celo library and wallet implementation in Rust.
  • etk - etk is a collection of tools for writing, reading, and analyzing EVM bytecode.
  • Forest - Rust Filecoin implementation.
  • Foundry - Foundry is a blazing fast, portable and modular toolkit for Ethereum application development written in Rust.
  • Grin - Evolution of the MimbleWimble protocol
  • hdwallet - BIP-32 HD wallet related key derivation utilities.
  • Holochain - Scalable P2P alternative to blockchain for all those distributed apps you always wanted to build.
  • ibc-rs - Rust implementation of the Interblockchain Communication protocol.
  • interBTC - Trustless and fully decentralized Bitcoin bridge to Polkadot and Kusama.
  • Joystream - A user governed video platform.
  • Lighthouse - Rust Ethereum Consensus Layer (CL) Client.
  • madara - Kaioshin is a blazing fast Starknet sequencer, based on substrate and written in Rust.
  • mev-inspect-rs - Ethereum MEV Inspector in Rust.
  • nearcore - decentralized smart-contract platform for low-end mobile devices.
  • Nervos CKB - Nervos CKB is a public permissionless blockchain, the common knowledge layer of Nervos network.
  • Nimiq - Rust implementation of Nimiq node.
  • opensea-rs - Rust bindings & CLI to the Opensea API and Contracts.
  • Parity-Bitcoin - The Parity Bitcoin client.
  • Parity-Bridge - Bridge between any two ethereum-based networks.
  • Parity-Ethereum - Fast, light, and robust Ethereum client.
  • Parity-Zcash - Rust implementation of the Zcash protocol.
  • phala-blockchain — Confidential smart contract blockchain based on Intel SGX and Substrate.
  • polkadot-sdk - The Parity Polkadot Blockchain SDK.
  • rbtc - Convert BTC to any currency and vice-versa.
  • revm - Revolutionary Machine (revm) is a fast Ethereum virtual machine written in rust.
  • rust-bitcoin - Library with support for de/serialization, parsing and executing on data structures and network messages related to Bitcoin.
  • rust-cardano - Rust implementation of Cardano primitives, helpers, and related applications.
  • rust-lightning — Bitcoin Lightning library written in Rust. The main crate,
    lightning
    , does not handle networking, persistence, or any other I/O. Thus,it is runtime-agnostic, but users must implement basic networking logic, chain interactions, and disk storage.po on linking crate.
  • sigma-rust - Rust implementation of ErgoTree interpreter and wallet-related features.
  • solana - Web-Scale Blockchain for fast, secure, scalable, decentralized apps and marketplaces.
  • Substrate - Generic modular blockchain template written in Rust.
  • Sui - A next-generation smart contract platform with high throughput, low latency, and an asset-oriented programming model powered by the Move programming language.
  • svm-rs - Solidity-Compiler Version Manager.
  • tendermint-rs - Rust implementation of Tendermint blockchain data structures and clients.
  • wagu - Generate a wallet for any cryptocurrency.
  • wagyu - Rust library for generating cryptocurrency wallets.
  • zcash — Zcash is an implementation of the "Zerocash" protocol.

Database

  • Atomic-Server - NoSQL graph database with realtime updates, dynamic indexing and easy-to-use GUI for CMS purposes.
  • CeresDB - CeresDB is a high-performance, distributed, schema-less, cloud native time-series database that can handle both time-series and analytics workloads.
  • cnosdb - An Open Source Distributed Time Series Database with high performance, high compression ratio and high usability.
  • CozoDb - A general-purpose, transactional, relational database that uses Datalog for query, is embeddable, and focuses on graph data and algorithms.
  • darkbird - HighConcurrency, RealTime, InMemory storage inspired by erlang mnesia.
  • Databend - A Modern Real-Time Data Processing & Analytics DBMS with Cloud-Native Architecture.
  • DB3 Network - DB3 is a community-driven blockchain layer2 decentralized database network.
  • DragonMap - A module for Redis adding support for 2nd level indexes over keys, supporting individual keys' expiration and automatic index grooming.
  • Garage - S3-compatible distributed object storage service designed for self-hosting at a small-to-medium scale.
  • GreptimeDB - An open-source, cloud-native, distributed time-series database with PromQL/SQL/Python supported.
  • indradb - Rust based graph database.
  • libmdbx-rs - Rust bindings for MDBX, a "fast, compact, powerful, embedded, transactional key-value database, with permissive license". This is a fork of mozilla/lmdb-rs with patches to make it work with libmdbx.
  • Lucid - High performance and distributed KV store accessible through a HTTP API.
  • Materialize - Streaming SQL database powered by Timely Dataflow.
  • Neon - Neon is a serverless open-source alternative to AWS Aurora Postgres. It separates storage and compute and substitutes the PostgreSQL storage layer by redistributing data across a cluster of nodes.
  • noria - Dynamically changing, partially-stateful data-flow for web application backends.
  • oasysdb - An embedded vector database designed to run on the edge. Lightweight and fast with HNSW indexing algorithm.
  • oxigraph - Oxigraph is a graph database implementing the SPARQL standard.
  • ParityDB - Fast and reliable database, optimised for read operation.
  • PumpkinDB - an event sourcing database engine.
  • Qdrant - An open source vector similarity search engine with extended filtering support.
  • qrlew - The SQL-to-SQL Differential Privacy layer.
  • Redis Oxide - A multi-threaded implementation of redis written in rust.
  • RisingWave - The next-generation streaming database in the cloud.
  • rsedis - A Redis reimplementation in Rust.
  • Skytable - A multi-model NoSQL database.
  • sled - A (beta) modern embedded database.
  • SQLSync - Multiplayer offline-first SQLite.
  • SurrealDB - A scalable, distributed, document-graph database.
  • tectonicdb - Fast, highly compressed standalone database and streaming protocol for order book ticks.
  • TerminusDB - open source graph database and document store
  • TerrabaseDB - A multi-model NoSQL database
  • tikv - A distributed KV database in Rust.
  • toydb - Distributed SQL database in Rust, written as a learning project.
  • WooriDB - General purpose time serial database inspired by Crux and Datomic.

Emulators

See also crates matching keyword 'emulator'.

  • Commodore 64
  • Flash Player
    • Ruffle — Ruffle is an Adobe Flash Player emulator written in the Rust programming language. Ruffle targets both the desktop and the web using WebAssembly.
  • Gameboy
  • GameMaker Advance
  • GameMaker
    • OpenGMK — OpenGMK is a modern rewrite of the proprietary GameMaker Classic engines, providing a full sourceport of the runner, a decompiler, a TASing framework, and libraries for working with gamedata yourself.
  • NES
  • Playstation
  • ZX Spectrum
  • Virtual Boy
  • Intel 8080 CPU
    • i8080 - Intel 8080 cpu emulator by Rust
  • Emulator Development tools

File manager

  • broot - A new way to see and navigate directory trees (get an overview of a directory, even a big one; find a directory then
    cd
     to it; never lose track of file hierarchy while you search; manipulate your files, ...), further reading dystroy.org/broot
  • joshuto - ranger-like terminal file manager written in Rust.
  • xplr - A hackable, minimal, fast TUI file explorer.
  • yazi - Blazing fast terminal file manager written in Rust, based on async I/O.

Games

See also Games Made With Piston.

  • angolmois-rust - A minimalistic music video game which supports the BMS format.
  • chess-tui - A Chess TUI implementation in rust.
  • citybound - The city sim you deserve.
  • ludusavi - Backup tool for PC game saves.
  • sokoban-rs - A Sokoban implementation
  • Zone of Control - A turn-based hexagonal strategy game.
  • rhex - hexagonal ascii roguelike
  • zemeroth - A small 2D turn-based hexagonal strategy game.
  • magog - A roguelike game in Rust
  • rsnake - Snake written in Rust.
  • rsnake - Snake written in Rust.
  • rust-doom - A renderer for Doom, may progress to being a playable game.
  • rust-quake - Quake map renderer in Rust
  • TGWM - An RPG with turned-based mechanics (work in progress).
  • rusted-ruins - Extensible open world rogue like game with pixel art.
  • thetawave-legacy - A space shooter game that strives to be an entry point for new game developers to make their first contributions.
  • Veloren - An open-world, open-source multiplayer voxel RPG.

Graphics

  • euclider - A real-time 4D CPU ray tracer.
  • papercraft - A tool to unwrap 3D models and create them in paper with scissors and glue.
  • resvg - An SVG rendering library.
  • rust-raytracer - An implementation of a very simple raytracer based on Ray Tracing in One Weekend by Peter Shirley in Rust.
  • rustracer — A PBR glTF 2.0 renderer based on Vulkan ray-tracing, written in Rust.
  • svgbob - converts ASCII diagrams into SVG graphics.
  • svgcleaner - tidies SVG graphics
  • tray_rust - A ray tracer.
  • rs_pbrt - Rust crate to implement a counterpart to the PBRT book's (3rd edition) C++ code.
  • vue-skia - Skia based 2d graphics vue rendering library. It is based on Rust to implement software rasterization to perform rendering.
  • Image processing:

Industrial automation

Observability

  • bioyino — A high-performance scalable StatsD compatible server.
  • gtsa - A simple solution to proxy gelf messages (messages for Graylog) to Sentry.
  • OpenObserve - OpenObserve is a cloud native observability platform built specifically for logs, metrics, traces and analytics designed to work at petabyte scale.
  • quickwit - Cloud-native and highly cost-efficient search engine for log management.
  • Scaphandre - A power consumption monitoring agent, to track host and each service power consumption and enable designing systems and applications for more sustainability. Designed to fit any monitoring toolchain (already supports prometheus, warp10, riemann...).
  • vector - A High-Performance, Logs, Metrics, & Events Router.

Operating systems

See also A comparison of operating systems written in Rust.

  • redox
  • rust_os
  • SteinsOS - An OS for armv8-a architecture.
  • Theseus - A safe-language, single address space and single privilege level OS written from scratch in pure Rust.
  • tock - A secure embedded operating system for Cortex-M based microcontrollers
  • nebulet - A microkernel that implements a WebAssembly "usermode" that runs in Ring 0.

Productivity

  • ast-grep - A CLI tool for code structural search, lint and rewriting. Written in Rust.
  • Bartib - A simple timetracker for the command line.
  • espanso - A cross-platform Text Expander written in Rust.
  • eureka - A CLI tool to input and store your ideas without leaving the terminal.
  • Furtherance - Time tracking app built with Rust and GTK4.
  • illa [ILLA Cloud] - Low-code internal tool builder written with Rust.
  • LLDAP - Simplified LDAP interface for authentication.
  • pier - A central repository to manage (add, search metadata, etc.) all your one-liners, scripts, tools, and CLIs.
  • subilo - A continuous deployment agent.

Routing protocols

  • Holo - Holo is a suite of routing protocols designed to support high-scale and automation-driven networks.
  • RustyBGP - BGP implemented in the Rust Programming Language.

Security tools

  • abcdict - A better customization password dictionary generator.
  • arp-scan-rs - A minimalistic ARP scan tool for fast local network scans.
  • badtouch - A scriptable network authentication cracker.
  • Cherrybomb - Stop half-done API specifications with a CLI tool that helps you avoid undefined user behaviour by validating your API specifications.
  • Cliws - A bind/reverse PTY shell with Windows & Linux support.
  • feroxbuster - A simple, fast, recursive content discovery tool written in Rust.
  • inspektor - A database protocol-aware proxy that is used to enforce access policies.
  • lethe - A secure cross-platform drive wiping utility.
  • LibAFL - Advanced Fuzzing Library - Slot your Fuzzer together in Rust! Scales across cores and machines. For Windows, Android, MacOS, Linux, no_std, etc.
  • libinjection-rs - Rust bindings for libinjection.
  • ObserverWard - Cross platform community web fingerprint identification tool.
  • ripasso - A password manager, filesystem compatible with pass.
  • rshijack - A TCP connection hijacker, rust rewrite of shijack.
  • rsocx - A bind/Reverse Socks5 proxy Server.
  • rustscan - Make Nmap faster with this port scanning tool.
  • sniffglue - A secure multithreaded packet sniffer.
  • sn0int - A semi-automatic OSINT framework and package manager.
  • anevicon - The most powerful UDP-based load generator, written in Rust.
  • finshir - A coroutines-driven Low & Slow traffic generator, written in Rust.

Social networks

  • Rustodon - A Mastodon-compatible, ActivityPub-speaking server in Rust.

System tools

  • atuin - Atuin replaces your existing shell history with a SQLite database, and records additional context for your commands. Additionally, it provides optional and fully encrypted synchronisation of your history between machines, via an Atuin server.
  • bat - A cat(1) clone with wings.
  • bingrep - Greps through binaries from various OSs and architectures, and colors them.
  • bottom - Yet another cross-platform graphical process/system monitor.
  • bustd - Lightweight process killer daemon to handle out-of-memory scenarios on Linux.
  • cicada - A bash-like Unix shell.
  • cocom - NTP client purely written in Rust.
  • concurr - Alternative to GNU Parallel w/ a client-server architecture.
  • coreutils - A cross-platform Rust rewrite of the GNU coreutils.
  • crabz - Multi-threaded compression and decompression CLI tool.
  • czkawka - Multi-functional app to find duplicates, empty folders, similar images, etc.
  • debrep - APT repository tool for building and managing an APT repo.
  • ddh - Fast duplicate file finder.
  • eza - A replacement for 'ls'.
  • fblog - Small command-line JSON Log viewer.
  • fclones - Efficient duplicate file finder and remover.
  • findex - Findex is a highly customizable application finder written in Rust and uses GTK3.
  • fuc - Fast
    cp
     and
    rm
     commands.
  • funzzy - A configurable filesystem watcher inspired by entr.
  • fontfinder - GTK3 application for previewing and installing Google's fonts.
  • fselect - Find files with SQL-like queries.
  • gitui - Blazing fast terminal client for git written in Rust.
  • goto - A simple and user-friendly way to jump to your indexed directories.
  • GQL - A SQL like query language to run on .git files.
  • httm - Interactive, file-level Time Machine-like tool for ZFS/btrfs/nilfs2 (and even actual Time Machine backups!)
  • kickoff - Fast and snappy wayland program launcher.
  • Kondo - CLI & GUI tool for deleting software project artifacts and reclaiming disk space.
  • nushell - A new type of shell.
  • rrun - A command launcher for Linux, similar to gmrun.
  • procs - A modern replacement for 'ps' written by Rust.
  • zou - A download accelerator.
  • rargs - xargs + awk with pattern matching support.
  • skim - A fuzzy finder in pure rust.
  • LACT - Linux AMDGPU Controller
  • lsd — An ls with a lot of pretty colors and awesome icons
  • parallel - Reimplementation of GNU Parallel
  • systemd-manager - A systemd service manager written in Rust using GTK-rs.
  • tv-renamer - A tv series renaming application with an optional GTK3 frontend.
  • lsd - An ls with a lot of pretty colors and awesome icons.
  • ouch - Painless compression and decompression on the command-line.
  • popsicle - GTK3 & CLI utility for flashing multiple USB devices in parallel.
  • pueue - Manage your long running shell commands.
  • synapse - Flexible and fast BitTorrent daemon.
  • system76-power - Linux power management daemon (DBus-interface) with CLI tool.
  • trippy - A network diagnostic tool.
  • logram - Push log files' updates to Telegram.
  • ion - Next-generation system shell.
  • fd - A simple, fast and user-friendly alternative to find.
  • hex - A colorized hexdump terminal utility.
  • watchexec - Executes commands in response to file modifications.
  • XAMPPRocky/tokei - counts the lines of code.
  • yake - Yake is a task runner based on yaml files.
  • ytop - A TUI system monitor written in Rust.
  • Voila - Voila is a domain-specific language launched through CLI tool for operating with files and directories in massive amounts in a fast & reliable way.

Text editors

  • amp - Inspired by Vi/Vim.
  • helix - A post-modern modal text editor inspired by Neovim/Kakoune.
  • iota - A simple text editor.
  • kibi - A tiny (≤1024 LOC) text editor with syntax highlighting, incremental search and more.
  • lapce - Lightning-fast and Powerful Code Editor written in Rust.
  • ox - An independent Rust text editor that runs in your terminal
  • pepper - An opinionated modal editor to simplify code editing from the terminal
  • Remacs - A community-driven port of Emacs to Rust.
  • rim - Vim-like text editor written in Rust.
  • xi-editor - A modern editor with a backend written in Rust.
  • xray - An experimental next-generation Electron-based text editor.
  • zed - A high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.

Text processing

  • bytelines - Read input lines as byte slices for high efficiency.
  • cfonts - Sexy ANSI fonts for the console.
  • cpc - Parses and calculates strings of math with support for units and unit conversion, from
    1+2
     to
    1% of round(1 lightyear / 14!s to km/h)
    .
  • ff - Find files (ff) by name!
  • grex - A command-line tool and library for generating regular expressions from user-provided test cases.
  • Melody - A language that compiles to regular expressions and aims to be more easily readable and maintainable.
  • ruplacer - Find and replace text in source files.
  • ripgrep - combines the usability of The Silver Searcher with the raw speed of grep.
  • ripgrep-all - ripgrep, but also search in PDFs, E-Books, Office documents, zip, tar.gz, etc.
  • sd - Intuitive find & replace CLI.
  • todo_r - Find all your TODO notes with one command!
  • runiq - an efficient way to filter duplicate lines from unsorted input.
  • so_stupid_search - A simple and fast string search tool for human beings.
  • qsv - A high performance CSV data-wrangling toolkit. Forked from xsv, with 34+ additional commands & more.
  • xsv - A fast CSV command line tool (slicing, indexing, selecting, searching, sampling, etc.)

Utilities

  • 1History - Command line interface to backup Firefox/Chrome/Safari history to one SQLite file.
  • AZDice - A dice roll success distribution generator for tabletop homebrewers.
  • barberousse - AWS Secrets Manager editor.
  • cb - Command line interface to manage clipboard.
  • checkpwn - A Have I Been Pwned (HIBP) command-line utility tool that lets you easily check for compromised accounts and passwords.
  • cloak - A Command Line OTP (One Time Password) Authenticator application.
  • consoletimer - Simple timer for your terminal.
  • cotp - Trustworthy encrypted one time password authenticator app compatible with external backups.
  • dtool - A useful command-line tool collection to assist development including conversion, codec, hashing, encryption, etc.
  • Epic Asset Manager — An unofficial client to install Unreal Engine, download and manage purchased assets, projects, plugins and games from the Epic Games Store.
  • freepass - The free password manager for power users.
  • gitweb - Open the current remote repository in your browser.
  • mdBook - mdBook is a utility to create modern online books from Markdown files.
  • mme - Command line tool to remember you commands that you sometimes forget.
  • mprocs — TUI for running multiple processes.
  • nix-init - Generate Nix packages from URLs with hash prefetching, dependency inference, license detection, and more.
  • nix-melt - A ranger-like flake.lock viewer.
  • nurl - Generate Nix fetcher calls from repository URLs.
  • nomino - Batch rename utility for developers.
  • oxker - A simple tui to view & control docker containers.
  • quick-skeleton - Project scaffolding tool, similar to Yeoman and Slush.
  • rubigo - Golang dependency tool and package manager, written in Rust.
  • s3-concat - A command line tool to concatenate Amazon S3 files remotely using flexible patterns.
  • s3-meta - A command line tool to gather metadata about your Amazon S3 buckets.
  • tmux-thumbs - A lightning fast version of tmux-fingers written in Rust, copy/pasting tmux like vimium/vimperator.
  • repoch - Convert epoch to datetime and datetime to epoch.
  • rewrk - A more modern http framework benchmarker supporting HTTP/1 and HTTP/2 benchmarks.
  • Warp — Warp is a blazingly-fast modern Rust based GPU-accelerated terminal built to make you and your team more productive.
  • 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!
  • wrestic - A wrapper around restic built in rust.

Video

  • camera_capture - Webcam capturing in Rust, captures webcam images and offers access to them through an iterator.
  • gyroflow - Video stabilization application using gyroscope data.
  • slingr - A simple CLI for streaming media files over a local network to UPnP media renderers.
  • streamlib - Play your favorite live video and audio streams from command line.
  • vidmerger - Merge video & audio files via CLI.
  • rav1e - The fastest and safest AV1 encoder.
  • yaydl - A simple video downloader

Virtualization

  • firecracker - A lightweight virtual machine for container workload Firecracker Microvm
  • kata-containers - A implementation of lightweight Virtual Machines (VMs) that feel and perform like containers, but provide the workload isolation and security advantages of VMs.
  • propolis - Rust-based userspace program for illumos bhyve kernel modules.
  • railcar - Docker-like container OCI runtime implementation in Rust.
  • vagga - A containerization tool without daemons.
  • wasmtime - A standalone runtime for WebAssembly.
  • xiu - A powerful and secure live server by pure rust (rtmp/httpflv/hls/relay).

Window managers

  • way-cooler - A customizable Wayland compositor (window manager)

Web

  • backend - User-first chat platform built with modern web technologies.
  • Bitwarden - Unofficial Bitwarden compatible server written in Rust, formerly known as bitwarden_rs.
  • delta - User-first chat platform built with modern web technologies.
  • lemmy - A link aggregator / reddit clone for the fediverse.
  • Plume - ActivityPub federating blogging application.
  • ruster - online community in rust for rust community.
  • spin - Spin is a framework for building, deploying, and running fast, secure, and composable cloud microservices with WebAssembly.
  • tobaru - Port forwarder with allowlists, IP and TLS SNI/ALPN rule-based routing, iptables support, round-robin forwarding (load balancing), and hot reloading.

Web Servers

  • Frolic - Frolic provides a ready made APIs to query all your data. This removes the need to write multiple APIs for different dashboard components and their database queries.
  • http - Host These Things Please - A basic http server for hosting a folder fast and simply.
  • leptos - Leptos is a full-stack, isomorphic Rust web framework leveraging fine-grained reactivity to build declarative user interfaces.
  • meilisearch - A lightning-fast search engine that fits effortlessly into your apps, websites, and workflow.
  • miniserve - A small, self-contained cross-platform CLI tool that allows you to just grab the binary and serve some file(s) via HTTP.
  • skyfolder - Beautiful HTTP/Bittorrent server without the hassle. Secure - GUI - Pretty - Fast.
  • simple-http-server - simple static http server.
  • see - Static file server.
  • rust-hasura - A demonstration of how a Rust GraphQL server can be used as a remote schema with Hasura
  • static-web-server - A blazing fast and asynchronous web server for static files-serving.

Development tools

  • artifact - the design doc tool made for developers.
  • bacon — background rust code checker, similar to cargo-watch.
  • clippy - Rust lints.
  • clog-cli - generates a changelog from git metadata.
  • comtrya - A configuration management tool for localhost / dotfiles.
  • create-rust-app - Set up a modern rust+react web app by running one command.
  • rusty-tags - create ctags/etags for a cargo project and all of its dependencies.
  • datanymizer - Powerful database anonymizer with flexible rules.
  • delta - A syntax-highlighter for git and diff output.
  • dotenv-linter - Linter for
    .env
     files.
  • envio - A Modern And Secure CLI Tool For Managing Environment Variables.
  • crate-deps - generates images of dependency graphs for crates hosted on crates.io
  • fw - workspace productivity booster.
  • git-journal - The Git Commit Message and Changelog Generation Framework.
  • hot-lib-reloader - Hot reload Rust code.
  • intelli-shell - Bookmark commands with placeholders and search or autocomplete at any timeю
  • just - A handy command runner for project-specific tasks.
  • mask - A CLI task runner defined by a simple markdown file.
  • 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.
  • rustfix - automatically applies the suggestions made by rustc.
  • rust_echo_bench - A simple rust echo server benchmark.
  • 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
  • semantic-rs - automatic crate publishing.
  • synth - A declarative data generation engine.
  • tinyrick a basic task dependency tool emphasizing Rust functions over raw shell commands.

Build system

  • Cargo - the Rust package manager

    • cargo-benchcmp - A utility to compare Rust micro-benchmarks.
    • cargo-bitbake - A cargo extension that can generate BitBake recipes utilizing the classes from meta-rust.
    • cargo-cache - inspect/manage/clean your cargo cache (
      ~/.cargo/
      /
      ${CARGO_HOME}
      ), print sizes etc.
    • cargo-check - A wrapper around
      cargo rustc -- -Zno-trans
       which can be helpful for running a faster compile if you only need correctness checks.
    • cargo-commander — A subcommand for
      cargo
       to run CLI commands similar to how the scripts section in
      package.json
       works.
    • cargo-count - lists source code counts and details about cargo projects, including unsafe statistics.
    • cargo-deb - Generates binary Debian packages.
    • cargo-deps - build dependency graphs of Rust projects.
    • cargo-do - run multiple cargo commands in a row.
    • cargo-ebuild - cargo extension that can generate ebuilds using the in-tree eclasses.
    • cargo-edit - allows you to add and list dependencies by reading/writing to your Cargo.toml file from the command line.
    • cargo-find deprecated - Find crates from command line.
    • cargo-generate A generator of a rust project by leveraging a pre-existing git repository as a template.
    • cargo-get - Cargo plugin to easily query information from Cargo.toml files.
    • cargo-graph - updated fork of
      cargo-dot
       with additional features. Unmaintained, see
      cargo-deps
      .
    • cargo-info - queries crates.io for crates details from command line.
    • cargo-make - Rust task runner and build tool.
    • cargo-modules - A cargo plugin for showing a tree-like overview of a crate's modules.
    • cargo-multi - runs specified cargo command on multiple crates.
    • cargo-outdated - displays when newer versions of Rust dependencies are available, or out of date.
    • cargo-release - tool for releasing git-managed cargo project, build, tag, publish, doc and push.
    • cargo-script - lets people quickly and easily run Rust "scripts" which can make use of Cargo's package ecosystem.
    • cargo-testify - watches files changes, runs tests and notifies about the result with friendly OS notification.
    • cargo-update - cargo subcommand for checking and applying updates to installed executables.
    • cargo-watch - utility for cargo to compile projects when sources change.
    • cargo-x - A very simple third-party cargo subcommand to execute a custom command.
    • cargo-expand - Expand macros in your source code

  • CMake

    • CMakeRust - useful for integrating a Rust library into a CMake project
    • RustCMake - an example project showing usage of CMake with Rust.

  • Github actions

  • Webpack

  • Fleet - The blazing fast build tool for Rust.

Debugging

Deployment

  • Docker
    • rust-musl-builder - Docker images for compiling static Rust binaries using musl-libc and musl-gcc, with static versions of useful C libraries
    • mini-docker-rust - An example project for very small rust docker images.
    • docker-rustup - A multiple version (with musl tools) Rust Docker image
    • rust-musl-cross - Docker images for compiling static Rust binaries using musl-cross.
    • docker-rust - the official Rust Docker image
  • Google App Engine
  • Heroku
  • release-plz - Release Rust crates from CI, with changelog generation and semver check.

Embedded

Rust Embedded

  • Arduino
    • ruduino ^`^t Reusable components for the Arduino Uno.
  • Cross compiling
    • rust-cross - everything you need to know about cross compiling Rust programs.
    • xargo - effortless cross compilation of Rust programs to custom bare-metal targets like ARM Cortex-M.
  • Espressif
    • esp-rs - home to a number of community projects enabling the use of the Rust programming language on various SoCs and modules produced by Espressif Systems.
  • Firmware
    • oreboot - oreboot is a fork of coreboot, with C removed, written in Rust.
  • nRF
    • nrf-hal - A Rust HAL for the nRF family of devices.
  • 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
    • cbindgen - generates C header files from Rust source files. Used in Gecko for WebRender.
    • safer_ffi - Framework that helps you write foreign function interfaces (FFI) without polluting your Rust code with unsafe { ... } code blocks while making functions far easier to read and maintain.
    • rusty-cheddar - generates C header files from Rust source files.
  • C++
    • CXX - This library provides a safe mechanism for calling C++ code from Rust and Rust code from C++, not subject to the many ways that things can go wrong when using bindgen or cbindgen to generate unsafe C-style bindings.
    • rust-bindgen - A Rust bindings generator.
  • Erlang
    • rustler - safe Rust bridge for creating Erlang NIF functions.
  • Go
  • Haskell
    • curryrs - Bridge the gap between Haskell and Rust
    • haskellrs - Rust in Haskell FFI Example
    • rushs - Haskell in Rust FFI Example
    • rust-go-example - An example of how to combine Rust and Go in the same program.
  • Java
  • Lua
    • rust-lua53 - Lua 5.3 bindings for Rust.
    • rust-lua - Safe Rust bindings to Lua 5.1
    • td_rlua - Zero-cost high-level lua 5.3 wrapper for Rust.
    • hlua - Rust library to interface with Lua.
  • mruby
    • mrusty - mruby safe bindings for Rust.
  • Node.js
    • neon - use Rust from Node.js
    • node-bindgen - Easy way to generate nodejs module using Rust.
    • node-ffi-rs - A module written in Rust and N-API provides interface (FFI) features for Node.js.
  • Objective-C
    • rust-objc - Objective-C Runtime bindings and wrapper for Rust
  • Perl
    • mi-rust - Adds support to M::I for building modules with Cargo
    • perl-xs - Create Perl XS modules using Rust.
  • PHP
    • phper - The framework that allows us to write PHP extensions using pure and safe Rust whenever possible.
  • Python
    • milksnake - extension for python setuptools that allows you to distribute dynamic linked libraries in Python wheels in the most portable way imaginable.
    • rust-cpython - Python bindings.
    • PyO3 - Rust bindings for the Python interpreter.
    • RustPython — A Python Interpreter written in Rust.
  • R
    • rustr - use Rust from R, and use R in Rust.
  • Ruby
    • ruru - native Ruby extensions written in Rust.
    • rutie - native Ruby extensions written in Rust and vice versa.
    • helix - write Ruby classes in Rust.
  • Web Assembly
    • wasm-pack - pack up the wasm and publish it to npm!
    • wasm-bindgen - A project for facilitating high-level interactions between wasm modules and JS.

Formatters

  • dprint - A pluggable and configurable code formatting platform.
  • Prettier Rust - An opinionated Rust code formatter that autofixes bad syntax (Prettier community plugin).
  • rustfmt - Rust code formatter maintained by the Rust team and included in cargo.

IDEs

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

Pattern recognition

  • rusteval - A tool used to evaluate the output of retrieval algorithms.

Profiling

  • Bencher - A suite of continuous benchmarking tools designed to catch performance regressions in CI.
  • criterion.rs - Statistics-driven benchmarking library for Rust.
  • hyperfine - A command-line benchmarking tool.
  • hornet - A Performance Co-Pilot memory-mapped values instrumentation library.
  • memory-profiler - A memory profiler for Linux.
  • puffin - The friendly little instrumentation profiler for Rust.
  • rust-stopwatch - A stopwatch library.
  • FlameGraphs
    • torch - generates FlameGraphs based on DWARF Debug Info
    • flame

Services

  • deps.rs - Detect outdated or insecure dependencies
  • docs.rs - Automatic documentation generation of crates

Static analysis

[assert, static]

Testing

[testing]

  • Code Coverage
    • tarpaulin - A code coverage tool designed for Rust.
  • Continuous Integration
    • 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
  • Frameworks and Runners
    • cargo-dinghy - A cargo extension to simplify running library tests and benches on smartphones and other small processor devices.
    • cucumber - An implementation of the Cucumber testing framework for Rust. Fully native, no external test runners or dependencies.
    • demonstrate - Declarative Testing Framework.
    • laboratory - A simple, expressive unit test framework for Rust.
    • polish - Mini Testing/Test-Driven Framework.
    • rewrk - A more modern http framework benchmarker supporting HTTP/1 and HTTP/2 benchmarks.
    • rstest - Fixture-based test framework for Rust.
    • ruspec - Write like Rspec testing framework with rust.
    • speculate - An RSpec inspired minimal testing framework for Rust.
    • test-log - A replacement of the
      #[test]
       attribute that initializes logging and/or tracing infrastructure before running tests.
    • Web Framework Benchmarks - Benchmarking web frameworks written in rust with rewrk tool.
  • Mocking and Test Data
    • fake-rs - A library for generating fake data.
    • goldenfile - A library providing a simple API for goldenfile testing.
    • httpmock - HTTP mocking.
    • mockiato - A strict, yet friendly mocking library for Rust 2018.
    • mockito - HTTP mocking.
    • faux - A library to create mocks out of structs.
    • synth — Generate database data declaratively.
  • Mutation Testing
    • cargo-mutants - Finds inadequately tested code by injecting mutations, no source changes required.
    • mutagen - A source-level mutation testing framework (nightly only).
  • Property Testing and Fuzzing

Transpiling

  • c2rust - C to Rust translator and cross checker built atop Clang/LLVM.
  • corrode - A C to Rust translator written in Haskell.
  • m2cgen — A CLI tool to transpile trained classic machine learning models into a native Rust code with zero dependencies.

Libraries

Artificial Intelligence

Genetic algorithms

  • 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.
  • genevo - Execute genetic algorithm (GA) simulations in a customizable and extensible way.
  • 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).
  • RsGenetic - Genetic Algorithm library in Rust. In maintenance mode.
  • evo-rs - Evolutionary Algorithm Library for Rust. Without changes for 3 years.
  • 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.

  • aichat - Using ChatGPT/GPT-3.5/GPT-4 in the terminal.
  • burn - A Flexible and Comprehensive Deep Learning Framework in Rust.
  • candle - a minimalist ML framework with a focus on easiness of use and on performance (including GPU support)
  • dfdx - CUDA accelearted machine learning framework that leverages many of Rust's unique features.
  • leaf - Open Machine Intelligence framework. Abandoned project. The most updated fork is spearow/juice.
  • rusty-machine - Machine learning library for Rust.
  • RusticSOM - Rust library for Self Organising Maps (SOM).
  • smartcore - Machine Learning Library In Rust.
  • tensorflow/rust - Rust language bindings for TensorFlow.
  • tokenizers - Hugging Face's tokenizers for modern NLP pipelines written in Rust (original implementation) with bindings for Python.
  • rustlearn - Machine learning crate for Rust.
  • tch-rs - Rust language bindings for PyTorch.

OpenAI

  • async-openai - Ergonomic Rust bindings for OpenAI API based on OpenAPI spec.
  • tiktoken-rs - Rust library for tokenizing text with OpenAI models using tiktoken.

Astronomy

[astronomy]

  • aladin-lite - Web application for visualizing spatial and planetary image surveys in different projections.
  • astro-rust - astronomy for Rust.
  • fitsio - fits interface library wrapping cfitsio.
  • rust-sun - A rust port of the JS library suncalc.

Asynchronous

  • async-backplane - Easy, Erlang-inspired fault-tolerance framework for Rust Futures.
  • async-channel - An async multi-producer multi-consumer channel.
  • async-dropper - Implementation of
    AsyncDrop
  • async-std - Async version of std. It provides all the interfaces you are used to, but in an async version and ready for Rust's async/await syntax.
  • mioco - Scalable, coroutine-based, asynchronous IO handling library.
  • fpRust - Monad/MonadIO, Handler, Coroutine/doNotation, Functional Programming features for Rust.
  • futures-lite - A lightweight async prelude.
  • futures-rs - Zero-cost futures in Rust.
  • mio - MIO is a lightweight IO library for Rust with a focus on adding as little overhead as possible over the OS abstractions.
  • may - rust stackful coroutine library.
  • runtime - A runtime agnostic API designed to make async feel like its part of stdlib.

Audio

[audio]

  • rust-fmod - FMOD bindings.
  • ears - A simple library to play Sounds and Musics, on top of OpenAL and libsndfile.
  • alto - OpenAL 1.1 bindings.
  • nodi - A library for playback and abstraction of MIDI files.
  • portmidi-rs - PortMidi bindings.
  • hound - A WAV encoding and decoding library.
  • rodio - A Rust audio playback library.
  • Symphonia - A pure Rust audio decoding and media demuxing library supporting AAC, FLAC, MP3, MP4, OGG, Vorbis, and WAV.

Authentication

  • canduma - A Rust authentication server with GraphQL API, Diesel, PostgreSQL session authentication and JWT.
  • jsonwebtoken - JSON Web Token lib in rust.
  • jwtvault - Async library to manage and orchestrate JWT workflow.
  • oauth2 - Extensible, strongly-typed Rust OAuth2 client library.
  • oxide-auth - A OAuth2 server library, for use in combination with actix or other frontends, featuring a set of configurable and pluggable backends.
  • totp-rs - 2fa library to generate and verify TOTP-based tokens.
  • yup-oauth2 - An oauth2 client implementation providing the Device, Installed and Service Account flows.

Automotive

Bioinformatics

  • Rust-Bio - bioinformatics libraries in Rust.

Caching

  • bmemcached-rs - Memcached library written in pure rust.
  • cached - Simple function caching/memoization.
  • cacache-rs - A high-performance, concurrent, content-addressable disk cache, optimized for async APIs.
  • hitbox - Asynchronous caching framework supporting multiple backends.
  • http-cache - A caching middleware that follows HTTP caching rules.
  • moka - A high performance concurrent caching library for Rust inspired by the Caffeine library for Java.
  • rust-memcache - Memcached client library.
  • sccache - Shared Compilation Cache, great for Rust compilation.
  • stretto - A high performance thread-safe memory-bound Rust cache.

Concurrency

  • archery [archery] - Library to abstract from
    Rc
    /
    Arc
     pointer types.
  • bus-writer - Generic single-reader, multi-writer
  • coroutine-rs - Coroutine Library in Rust.
  • coio-rs - Coroutine I/O for Rust.
  • crossbeam - Support for parallelism and low-level concurrency in Rust.
  • glock - Granular locking crate for Rust.
  • kanal - Kanal is a Rust library to help programmers design effective programs in CSP model via providing featureful multi-producer multi-consumer channels.
  • left-right - A lock-free, read-optimized, concurrency primitive.
  • Rayon - A data parallelism library for Rust.
  • scipio - Cooperative Thread-per-Core crate for Rust & Linux based on io_uring. Like other rust asynchronous crates it allows one to write asynchronous code that takes advantage of rust async/await, but unlike its counterparts it doesn't use helper threads anywhere.

Cloud

  • AWS [aws]

  • Multi Cloud

    • Qovery/engine - Abstraction layer library that turns easy application deployment on Cloud providers in just a few minutes.

Command-line

  • Argument parsing
    • clap-rs - A simple to use, full featured command-line argument parser.
    • docopt.rs - A Rust implementation of DocOpt
    • pflag - A port of @spf13's amazing POSIX compliant arg parsing library in Go.
    • structopt - parse command line argument by defining a struct.
    • quicli - quickly build cool CLI apps in Rust.
    • seahorse - A minimal CLI framework written in Rust.
  • Data visualization
    • comfy-table - Beautiful dynamic tables for your cli tools.
    • rspark - Sparklines for Rust apps.
  • Human-centered design.
  • Line editor
    • rust-copperline - pure-Rust command line editing library
    • liner - A library offering readline-like functionality.
    • linefeed - Configurable, extensible, interactive line reader.
    • rustyline - readline implementation in Rust.
  • Other
    • update-informer - Update informer for CLI applications. It checks for a new version on Crates.io and GitHub.
  • Pipeline
    • pager-rs - pipe your output through an external pager.
    • rust-subprocess - facilities for interaction with external pipelines.
    • duct.rs - A builder for subprocess pipelines and IO redirection.
    • rexpect - automate interactive applications such as ssh, ftp, passwd, etc.
  • Progress
    • indicatif - indicate progress to users
    • pb [pbr] - console progress bar for Rust
    • spinners - 60+ elegant terminal spinners
  • Prompt
  • Style
    • bunt - cross-platform terminal colors and styling with macros.
    • dialoguer - A rust library for command line prompts and similar things.
    • rust-ansi-term - control colours and formatting on ANSI terminals.
    • term-painter - cross-platform styled terminal output.
    • termstyle - build (and test) formatted and styled command line applications
    • yansi - A dead simple ANSI terminal color painting library
  • TUI

Compression

  • 7z
    • sevenz-rust - A 7z decompressor/compressor written in pure rust.
  • Brotli
    • brotli-rs - implementation of Brotli compression
    • rust-brotli - Brotli decompressor in Rust that optionally avoids the stdlib
  • bzip2
  • gzip
    • zopfli - implementation of the Zopfli compression algorithm for higher quality deflate or zlib compression.
  • gzp
    • gzp - multi-threaded encoding and decoding of deflate formats and snappy.
  • miniz
  • snappy
  • tar
    • tar-rs - tar archive reading/writing in Rust.
  • zip
    • zip-rs - read and write ZIP archives.
  • Columnar compression
    • compressed-vec - SIMD Floating point and integer compressed vector library

Computation

Configuration

  • config-rs [config] - Layered configuration system for Rust applications (with strong support for 12-factor applications).
  • configure_me [configure_me] - library for processing application configuration easily.
  • configster [configster] - Rust library for parsing configuration files.
  • justconfig - Easily extendable, layered configuration library that introduces no additional dependencies into your project.
  • uclicious [uclicious] - libUCL based feature-rich configuration library.
  • envy - deserialize env vars into typesafe structs.

Cryptography

[crypto, cryptography]

  • ark-circom - Arkworks bindings to Circom's R1CS, for Groth16 Proof and Witness generation in Rust.

  • ring - Safe, fast, small crypto using Rust and BoringSSL's cryptography primitives.

  • webpki - Web PKI TLS X.509 certificate validation in Rust.

  • 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.

  • rustls - A Rust implementation of TLS

  • rust-crypto - cryptographic algorithms in Rust.

  • sodiumoxide - libsodium bindings.

  • libblockchain - A Blockchain implementation.

  • exonum - extensible framework for blockchain projects.

  • octavo - Modular hash and crypto library in Rust.

  • opaque-ke - Pure Rust implementation of the recent [OPAQUE]

  • hashes - Collection of cryptographic hash functions written in pure Rust.

  • mpw-rs - Pure Rust implementation of the Master Password password manager.

  • rabe - Library providing several Attribute-Based Encryption (ABE) schemes

  • randomorg - A random.org client library.

  • 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-rs - Pure Rust implementation of the RNCryptor AES file format

  • rooster - Simple password manager to use in your terminal

  • rust-native-tls - Bindings for native TLS libraries

  • rust-openssl - OpenSSL bindings.

  • rust-security-framework - Bindings for Security Framework (OSX native crypto).

  • rustotpony - CLI manager of one-time password generators aka Google Authenticator (TOTP).

  • schannel-rs - Bindings for Schannel (Windows native TLS).

  • scryptenc-rs - An implementation of the scrypt encrypted data format.

  • suruga - A Rust implementation of TLS 1.2

  • themis - a high-level cryptographic library for solving typical data security tasks, best fit for multi-platform apps.

  • PKCS11 [pkcs11]

Database

[database]

Data processing

  • ndarray - N-dimensional array with array views, multidimensional slicing, and efficient operations.
  • polars - Polars is a blazingly fast DataFrames library implemented in Rust using Apache Arrow Columnar Format as the memory model.
  • utah - Dataframe structure and operations in Rust.
  • weld - High-performance runtime for data analytics applications.
  • yata - high perfomance technical analysis library.

Data streaming

  • arroyo - High-performance real-time analytics in Rust and SQL.
  • iggy - Persistent message streaming platform, supporting QUIC, TCP and HTTP transport protocols.
  • fluvio - Programmable high-performance distributed data streaming platform, built to make it easy to run real-time applications.

Data structures

  • Algorithms - All Algorithms implemented in Rust.
  • 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.
  • contain-rs - Extension of Rust's std::collections
  • enum-map - An optimized map implementation for enums using an array to store values.
  • extprim - Extra primitive types (u128, i128) for Rust.
  • flatbuffers-pool - RAII based FlatBufferBuilder pool.
  • generic-array - a hack to allow for arrays sized by typenums.
  • grid - Provide a two dimensional data structure for rust that is easy to use and fast.
  • hypergraph - Hypergraph is a data structure library to generate directed hypergraphs.
  • kdtree-rs - K-dimensional tree in Rust for fast geospatial indexing and nearest neighbors lookup.
  • nutype - define newtype structures with validation constraints.
  • priority-queue[priority-queue] - A priority queue that implements priority changes.
  • progress-streams - Progress callbacks for types which implement
    dyn io::Read
     or
    dyn io::Write
    .
  • roaring-rs - Roaring Bitmaps in Rust.
  • rpds [rpds] - Persistent data structures in Rust.
  • rust-itertools
  • scapegoat - Safe, fallible, stack-only alternative to BTreeSet and BTreeMap.
  • tst [tst] - Ternary search tree collection.
  • usher [usher] - Parameterized routing for generic resources in Rust.

Data visualization

  • egui_graphs - Interactive graph visualization widget for rust powered by egui and petgraph.
  • gust - A charting library for rust.
  • pgfplots - A Rust library to generate publication-quality figures.
  • plotly - Plotly for Rust.
  • plotlib
  • plotters
  • pretty-hex - A Rust library providing pretty hex dump.
  • rerun - An SDK for logging computer vision and robotics data (tensors, point clouds, etc) paired with a visualizer for exploring that data over time.

Date and time

[date, time]

Distributed systems

  • Aurae - Distributed systems runtime daemon written in Rust.
  • Ballista - Ballista is a distributed compute platform primarily implemented in Rust, using Apache Arrow as the memory model. It is built on an architecture that allows other programming languages to be supported as first-class citizens without paying a penalty for serialization costs.
  • Bastion - Highly-available, fault-tolerant runtime system with dynamic, dispatch-oriented, lightweight process model. It supplies actor-model-like concurrency with a lightweight process implementation and utilizes all of the system resources efficiently guaranteeing of at-most-once message delivery.
  • Coerce-rs - Coerce-rs is an asynchronous (async/await) Actor runtime and distributed system framework for Rust. It allows for extremely simple yet powerful actor-based distributed system development.
  • Antimony
  • Apache Hadoop
    • efflux - Easy Hadoop Streaming and MapReduce interfaces in Rust.
  • Apache Kafka
  • Beanstalkd
  • HDFS
  • Other
    • ockam - End-to-End Encryption, Mutual Authentication, and ABAC for distributed applications.

Domain driven design

Email

[email, imap, smtp]

  • Gatarashii_imap - 新しい (atarashii/new) IMAP client in Rust. It supports plain and secure connections.
  • imap-codec - Rock-solid and complete codec for IMAP.
  • sendgrid-rs - unofficial Rust library for SendGrid API.
  • lettre - an SMTP-library for Rust.
  • mail-auth - DKIM, ARC, SPF and DMARC message authentication library.
  • mail-parser - A fast and robust e-mail parsing library with full MIME support.
  • mailcrab - Email test server for development.
  • mailparse - A library for parsing real-world email files.
  • mailtutan - An SMTP server for test and development environment.
  • meli - terminal mail client.
  • mrml - A library to generate nice email templates working on any mail client.
  • catapulte - A microservice to send emails using MRML templates.
  • jolimail - A web application to build MRML templates.
  • vSMTP - A next-gen Mail Transfer Agent (MTA) written in Rust.

Encoding

[encoding]

Filesystem

[filesystem]

  • Libraries

    • rust-file-seq - Fail-safe sequence implementation that uses the file system as store.

  • Operations

    • Camino - Like Rust's std::path::Path, but UTF-8.
    • Rust_Search - Blazingly fast file search library built in Rust.
    • dbus-udisks2 -> UDisks2 DBus API
    • sys-mount - High level abstraction for the
      mount
       /
      umount2
       system calls.
    • path_abs - Absolute serializable path types and associated methods.
    • fs_extra - expanding opportunities standard library std::fs and std::io

  • Temporary Files

    • tempdir - temporary directory library.
    • tempfile - temporary file library.
    • xattr [xattr] - list and manipulate unix extended file attributes.
    • zbox [zbox] - Zero-details, privacy-focused embeddable file system.

Financial

  • apca - Opinionated and comprehensive bindings to the Alpaca API for stock trading and more.
  • bank-rs - Provides interfaces for bank transactions.
  • currency-rs - A very small library, providing a way to represent currencies in Rust.
  • iso20022 - ISO 20022 Universal Financial Industry Messages in Rust.
  • iso_currency - This crate provides an enum that represents all ISO 4217 currencies and has simple methods to convert between numeric and character code, list of territories where each currency is used, the symbol, and the English name of the currency.
  • iso-4217 - This library provides enumeration of ISO-4217.
  • diem - Libra Core implements a decentralized, programmable database which provides a financial infrastructure that can empower billions of people.
  • hyperswitch - An open source payments orchestrator that lets you connect with multiple payment processors and route payment traffic effortlessly, all with a single API integration.
  • offset - Offset is a credit card powered by trust between people.
  • OpenLibra CLI - The "open-libra" Command Line Interface (CLI) utility for devnet setup.
  • penny - ISO-4217–based currency library for Rust.
  • rust-decimal - A Decimal Implementation written in pure Rust suitable for financial calculations.
  • rusty-money - A library that handles calculating, rounding, displaying, and parsing units of money according to ISO 4217 standards. The main items exported by the library are Money and Currency.
  • RustQuant - A quantitative finance library.

ISO8583

[ISO8583]

  • iso8583 - Iso8583 Message Parser (Serialize/Deserialize).
  • iso8583_rs - ISO8583 library written in Rust.
  • lakgves - HTTP to ISO8583 message converter, written from scratch in Rust and heavily inspired by JUKS' socket queue. The main purpose of the system is testing Issuer Bank systems.

Framework

  • Abscissa - Microframework for building Rust applications (either CLI tools or network/web services), aiming to provide a large number of features with a minimal number of dependencies, and with a strong focus on security.
  • exonum - Extensible open-source framework for creating blockchain applications. Exonum can be used to create cryptographically powered distributed ledgers in virtually any problem domain, including FinTech, GovTech, and LegalTech. The Exonum framework is oriented towards creating permissioned blockchains, that is, blockchains with the known set of blockchain infrastructure providers.
  • ntex - Framework for composable network services.
  • salvo - Salvo is a simple web framework written by rust. It is simple to use it to build website, REST API.
  • Seed - Seed is a front-end Rust framework for creating fast and reliable web apps with an elm-like architecture.
  • Shio - Shio is a fast, simple, and asynchronous micro web-framework for Rust.
  • tsukuyomi - Asynchronous Web framework for Rust.

Game development

See also Are we game yet?

  • Allegro
  • Bracket-lib (previously RLTK)
    • bracket-lib - The Roguelike Toolkit (RLTK), implemented for Rust.
  • Challonge
  • Corange
  • Entity-Component Systems (ECS)
    • specs - Specs Parallel ECS.
  • Game Engines
    • Amethyst - Data-oriented game engine.
    • Bevy - is a refreshingly simple data-driven game engine built in Rust.
    • 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
    • Vulkust - Vulkust - A safe, highly multithreaded, Vulkan based game engine written with Rust.
  • Godot
  • SDL [sdl]
  • SFML
  • Tcod-rs
    • tcod-rs - Libtcod bindings for Rust.
  • Victorem
    • Victorem [Victorem] - Easy UDP Game Server and UDP Client framework for creating simple 2D and 3D online game prototype.
  • Voxlap

Geospatial

[geo, gis]

Graph algorithms

  • graph - A library for high-performant graph algorithms.
  • petgraph - Graph data structure library for Rust.

Graphics

[graphics]

Graph processing

  • tinkerpop-rs - an example how to use Apache TinkerPop from Rust.

GUI

[gui]

  • autopilot-rs - A simple, cross-platform GUI automation library for Rust.

  • azul - A free, functional, IMGUI-oriented GUI framework for rapid development of desktop applications written in Rust, supported by the Mozilla WebRender rendering engine.

  • conrod - An easy-to-use, immediate-mode, 2D GUI library written entirely in Rust.

  • dioxus - A portable, performant, and ergonomic framework for building cross-platform user interfaces in Rust.

  • Druid - Druid is an experimental Rust-native UI toolkit.

  • iced - A cross-platform GUI library for Rust focused on simplicity and type-safety. Inspired by Elm.

  • OrbTk - The Orbital Widget Toolkit is a cross-platform (G)UI toolkit for building scalable user interfaces with the programming language Rust. It's based on the Entity Component System Pattern and provides a functional Reactive-like API.

  • Pake - Turn any webpage into a desktop app with Rust with ease.

  • rise-ui - Simple component-based cross-Platform GUI Toolkit for developing beautiful and user-friendly interfaces.

  • rust_minifb - minifb is a cross-platform window setup with optional bitmap rendering. It also comes with easy mouse and keyboard input. Primarily designed for prototyping.

  • xilem — Successor of the data-first Rust-native UI design toolkit druid.

  • Cocoa

  • Flutter

    • flutter-rs - Build flutter desktop app in dart & rust.
    • flutter_rust_bridge - High-level memory-safe binding generator for Flutter/Dart <-> Rust.
    • rinf - Rust as your Flutter backend, Flutter as your Rust frontend.

  • GTK+ [gtk]

    • gtk - GTK+ bindings.
    • relm - Asynchronous, GTK+-based, GUI library, inspired by Elm.

  • ImGui

  • IUP

    • clear-coat - Clear Coat is a Rust wrapper for the IUP GUI library
    • iup-rust - IUP bindings.
    • Kiss-ui - A simple UI framework built on IUP.

  • libui

  • makepad - Makepad is a creative software development platform for Rust that compiles to wasm/webGL, osx/metal, windows/dx11 linux/opengl.

  • Nuklear

  • Qt

  • nfd-rs - nativefiledialog bindings

  • Sciter

Image processing

  • cv - Rust CV is a project to implement computer vision algorithms, abstractions, and systems in Rust. #[no_std] is supported where possible.
  • dominant_color - Dominant color extractor.
  • img_hash - Perceptual image hashing and comparison for equality and similarity.
  • image - Basic imaging processing functions and methods for converting to and from image formats.
  • imageproc - An image processing library, based on the
    image
     library.
  • opencv-rust - Rust bindings for OpenCV.
  • oxipng - Multithreaded PNG optimizer written in Rust.
  • steganography [steganography] - A simple steganography library.

Language specification

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

Logging

[log]

  • fast_log - Rust async log High-performance asynchronous logging.
  • log - Logging implementation for Rust.
  • log - Logging implementation for Rust.
  • slog - Structured, composable logging for Rust.
  • log4rs - highly configurable logging framework modeled after Java's Logback and log4j libraries.
  • paris - Simple way to output beautiful text in your CLI applications. Only limit is your imagination.
  • tailspin - A log file highlighter.
  • tracing - An application level tracing framework for async-aware structured logging, error handling, metrics, and more.

Macro

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

Markup language

Memory

Messaging

  • floki - Floki Message Queue.

Miscellaneous

Uncategorized

  • lance - Lance is a columnar data format that is easy and fast to version, query and train on. It’s designed to be used with images, videos, 3D point clouds, audio and of course tabular data. Alternative to Parquet. 100x faster for random access, includes a vector index and automatic versioning. Apache Arrow and DuckDB compatible.

Mobile

  • Generic

    • rust_on_mobile
    • redbadger/crux - Cross-platform app development in Rust. Crux helps you share your app's business logic and behavior across mobile (iOS/Android) and web — as a single reusable core built with Rust.

  • Android

  • iOS

    • cargo-lipo - A cargo lipo subcommand which automatically creates a universal library for use with your iOS application.
    • ObjCrust - using Rust to create an iOS static library.

  • Pebble

    • pebble.rs - A crate that allows Rust to be used to develop Pebble applications.

Network programming

  • HTTP
    • Hurl — Run and test HTTP requests with plain text and libcurl.
    • parallel-getter - Download a file with parallel GET requests to maximize bandwidth usage.
    • url-crawler - A configurable parallel web crawler, designed to crawl a website for content.
    • url-scraper - Scrape URLs from HTML pages
  • FTP
  • IPNetwork
    • ipnetwork - A library to work with IP networks in pure Rust.
    • netsim - A Rust library for network simulation and testing.
    • online — Library to check your Internet connectivity.
  • gRPC
    • grpc-rs - The gRPC library for Rust built on C Core library and futures.
    • Tonic - A rust implementation of gRPC, a high performance, open source, general RPC framework that puts mobile and HTTP/2 first.
  • JSON-RPC
  • Low level
    • actix - Actor library for Rust.
    • kay - Experimental high-performance actor system framework for Rust.
    • libpnet - A cross-platform, low level networking.
    • monoio - A thread-per-core Rust runtime with io_uring.
    • pingora - A library for building fast, reliable and evolvable network services.
    • protocol - Custom TCP/UDP protocol definitions.
    • riker - Easily build efficient, highly concurrent and resilient applications. An Actor Framework for Rust.
    • sendmmsg - Transmit multiple messages using one system call in Rust.
    • tokio - A network application framework for rapid development and highly scalable production deployments of clients and servers.
    • tower - Tower is a library of modular and reusable components for building robust networking clients and servers.
  • MQTT
    • rumqtt - A library for developers to build applications that communicate with the MQTT protocol over TCP and WebSockets, with or without TLS.
  • NanoMsg
  • Nng
  • NNTP
  • POP3
  • Raknet
    • rust-raknet - RakNet Protocol implementation by Rust.
  • Socket.io
  • SSH
  • Stomp
  • uTP
    • rust-utp - A uTP (Micro Transport Protocol) library for Rust.
  • ZeroMQ
  • CoAP
  • Docker
    • bollard - Docker daemon API in Rust
  • RPC
    • rpcx-rs - A RPC library for Rust for developing microservices in easy and simple way.
  • QUIC
    • neqo - an Implementation of QUIC written in Rust.
    • quiche - cloudflare implementation of the QUIC transport protocol and HTTP/3.
    • quinn - Futures-based QUIC implementation in Rust.
    • s2n-quic - An implementation of the IETF QUIC protocol.
  • P2P
    • rust-libp2p - The Rust Implementation of libp2p networking stack.
  • NATS
    • nats.rs - Rust client for NATS, the cloud native messaging system.

Parsing

  • chomp - A fast monadic-style parser combinator.
  • combine - parser combinator library.
  • lalrpop - LR(1) parser generator for Rust.
  • libazdice - A parser for parsing dice strings for TTRPGs and TTRPG development
  • nom - parser combinator library.
  • oak - A typed PEG parser generator (compiler plugin)
  • inquerest - an URL parameter parser for rest filter inquiry.
  • rust-peg - Parsing Expression Grammar (PEG) parser generator.
  • rust-shlex - Split a string into shell words, like Python's shlex.
  • robotstxt - A native Rust port of Google's robots.txt parser and matcher C++ library.
  • zero - zero-allocation parsing of binary data.
  • pest - The Elegant Parser.
  • queryst - A query string parsing library for Rust inspired by https://github.com/ljharb/qs
  • jsonpath - JsonPath engine written in Rust. Webassembly and Javascript support too.
  • wavefront_rs - A parser for the Wavefront OBJ format.

Packaging formats

  • debarchive Library for reading and extracting debian archives

Peripherals

Platform specific

QrCode

Libraries for manipulating with QrCodes.

Scripting

[scripting]

  • duckscript - Simple, extendable and embeddable scripting language.
  • dyon - A rusty dynamically typed scripting language.
  • gluon - A small, statically-typed, functional programming language
  • KCLVM - A constraint-based record & functional language mainly used in configuration and policy scenarios.
  • ketos - A Lisp dialect functional programming language serving as a scripting and extension language for rust
  • moss - A dynamically typed scripting language
  • rhai - A tiny and fast embedded scripting language resembling a combination of JS and Rust

Simulation

  • bigbang - Gravitational and collisional n-body simulation with optional GPU acceleration.
  • hEngine - A Rust-implemented computational simulation engine, supporting large-scale agent-based modelling, with simulation logic written in JavaScript and Python.
  • nyx-space - High fidelity, fast, reliable and validated astrodynamical toolkit library, used for spacecraft mission design and orbit determination.

Task scheduling

  • delay-timer - delay-timer is a task manager based on a time wheel algorithm, which makes it easy to manage timed tasks, or to periodically execute arbitrary tasks such as closures.
  • delicate - A lightweight and distributed task scheduling platform written in rust.

Template engine

  • Handlebars
    • handlebars-rust - Handlebars template engine with inheritance, custom helper support.
    • yarte - compile-time handlebars-like templates
  • HTML
    • maud - compile-time HTML templates
    • horrorshow-rs - compile-time HTML templates
    • ructe - HTML template system for Rust
    • tera - template engine based on Jinja2 and the Django template language.
    • askama - template rendering engine based on Jinja.
    • hiccup - template engine inpired by Clojure's Hiccup.
  • Mustache
    • rustache - Rust implementation of the Mustache specification.
  • marafet - Compiler for Jade-like template language to cito.js-based virtual dom
  • sailfish - Simple, small, and extremely fast template engine.

Text processing

  • complate - A in-terminal text templating tool designed for standardizing messages (like for GIT commits).
  • decancer [decancer] — A tiny package that removes common unicode confusables/homoglyphs from strings.
  • easy_reader - A reader that allows forwards, backwards and random navigations through the lines of huge files without consuming iterators.
  • ngrams - Construct n-grams from arbitrary iterators.
  • suffix - Linear time suffix array construction (with Unicode support).
  • strsim-rs - String similarity metrics.
  • tabwriter - Elastic tab stops (i.e., text column alignment).
  • textwrap [textwrap] - Word wrap text (with support for hyphenation).
  • regex - Regular expressions (RE2 style).
  • whatlang-rs - Natural language detection library based on trigrams.
  • rake-rs - Multilingual implementation of RAKE algorithm for Rust.
  • joinery [joinery] – Generic string + iterable joining.

Text search

  • MeiliSearch - Is a powerful, fast, open-source, easy to use and deploy search engine. Both searching and indexing are highly customizable. Features such as typo-tolerance, filters, and synonyms are provided out-of-the-box.
  • fst - Represent large sets and maps compactly with finite state transducers.
  • Perlin - An Efficient and Ergonomic Document Search-Engine
  • tantivy - full text search engine library written in Rust.

Video

  • ffmpeg-sidecar - Wrap a standalone FFmpeg binary in an intuitive Iterator interface.

Virtualization

  • quantum - Advanced Rust quantum computer simulator.
  • crosvm CrOSVM - Enables Chrome OS to run Linux apps inside a fast, sercure virtualized environment
  • unicorn-rs - Rust bindings for the unicorn CPU emulator
  • hypervisor-rs - Hardware-accelerated virtualization on OS X

Web programming

See also Are we web yet? and Rust web framework comparison.

  • Client-side / WASM
    • cargo-web - A Cargo subcommand for the client-side Web.
    • stdweb - A standard library for the client-side Web.
    • yew - Rust framework for making client web apps
  • Gemini
    • agate - Very simple server for the Gemini hypertext protocol.
  • HTTP Client
    • async-graphql - A GraphQL server library implemented in Rust.
    • curl-rust - libcurl bindings.
    • hyper - relatively low-level library, meant to be a building block for libraries and applications.
    • reqwest - an ergonomic HTTP Client for Rust.
    • yukikaze - Beautiful and elegant Yukikaze is little HTTP client library based on hyper.
    • graphql-client — Typed, correct GraphQL requests and responses in Rust.
  • HTTP Server
    • actix-web - A lightweight async web framework for Rust with websocket support.
    • Anansi - A simple full-stack web framework for Rust.
    • axum - web application framework that focuses on ergonomics and modularity.
    • branca - A Pure Rust implementation of Branca for Authenticated and Encrypted API tokens.
    • Gotham - A flexible web framework that does not sacrifice safety, security or speed.
    • hyper - an HTTP implementation.
    • frank_jwt - JSON Web Token implementation in Rust.
    • juniper - Juniper makes it possible to write GraphQL servers in Rust that are type-safe and blazingly fast. We also try to make declaring and resolving GraphQL schemas as convenient as Rust will allow.
    • handlebars-rust - an Iron web framework middleware.
    • Iron - A middleware-based server framework.
    • Nickel - inspired by Express
    • poem - A full-featured and easy-to-use web framework with the Rust programming language.
    • oxidy - Super Fast & High Performance minimalist web framework for rust.
    • Resty - simple JSON REST-API framework for Rust.
    • 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.
    • sapper - A lightweight web framework built on async hyper, implemented in Rust language.
    • tiny-http - Low level HTTP server library.
    • rouille - Web framework in Rust.
    • tower-web - A fast, boilerplate free, web framework for Rust.
    • sincere - A micro web framework for Rust(stable) based on hyper and multithreading.
    • zap - A lightning fast http framework for Rust.
    • xitca-web - An alternative http library and web framework inspired by hyper and actix-web.
  • WebSocket
    • fastwebsockets - A fast RFC6455 WebSocket implementation.
    • sockjs - A SockJS server for Rust.
    • rust-websocket - A framework for dealing with WebSocket connections (both clients and servers).
    • ws-rs - lightweight, event-driven WebSockets for Rust.
    • tungstenite-rs - Lightweight stream-based WebSocket implementation for Rust.
    • websocat - CLI for interacting with WebSockets, with functionality of Netcat, Curl and Socat.
    • urlshortener-rs - A very simple urlshortener library for Rust.
  • Miscellaneous
    • cargonauts - A web framework intended for building maintainable, well-factored web apps.
    • oso - A policy engine for authorization that's embedded in your application.
    • rust-embed - A macro to embed static assets into the rust binary.
    • serenity - A Rust library for the Discord API
    • openapi — A library for processing openapi spec files
    • svix-webhooks - A library for sending webhooks and verifying signatures.
    • tbot - Make cool Telegram bots with Rust easily.
    • teloxide - An elegant Telegram bots framework for Rust.
    • select.rs- A library to extract useful data from HTML documents, suitable for web scraping.
    • soup - A library similar to Pythons BeautifulSoup, designed to enable quick and easy manipulation and querying of HTML documents.
    • xh - Friendly and fast tool for sending HTTP requests.
  • Reverse Proxy
    • sozu - A HTTP reverse proxy.
  • Static Site Generators
    • zola [zola] - An opinionated static site generator with everything built-in.
    • cobalt.rs - Static site generator written in Rust.
    • mdblog.rs - Static site generator from markdown files.
    • leven - A simple, parallelized blog generator.

Registries

A registry allows you to publish your Rust libraries as crate packages, to share them with others publicly and privately.

  • chartered - A private, authenticated, permissioned Cargo registry.
  • Crates - The official public registry for Rust/Cargo.
  • Cloudsmith - A fully managed package management SaaS, with first-class support for public and private Cargo/Rust registries (plus many others). Has a generous free-tier and is also completely free for open-source.

Resources

Использование cookies

Мы используем файлы cookie в соответствии с Политикой конфиденциальности и Политикой использования cookies.

Нажимая кнопку «Принимаю», Вы даете АО «СберТех» согласие на обработку Ваших персональных данных в целях совершенствования нашего веб-сайта и Сервиса GitVerse, а также повышения удобства их использования.

Запретить использование cookies Вы можете самостоятельно в настройках Вашего браузера.