async-trait

https://crates.io/crates/async-trait

The initial round of stabilizations for the async/await language feature in Rust 1.39 did not include support for async fn in traits.

auditable

https://github.com/Shnatsel/rust-audit

Know the exact crate versions used to build your Rust executable. Audit binaries for known bugs or security vulnerabilities in production, at scale, with zero bookkeeping.

Chrono

https://crates.io/crates/chrono

Chrono: Date and Time for Rust

clap

https://crates.io/crates/clap

Command Line Argument Parser for Rust

Crossbeam

https://crates.io/crates/crossbeam

This crate provides a set of tools for concurrent programming.

curl-rust

https://github.com/alexcrichton/curl-rust

libcurl bindings for Rust

human-panic

https://crates.io/crates/human-panic [GitHub]

Panic messages for humans. Handles panics by calling std::panic::set_hook to make errors nice for humans.

image

https://crates.io/crates/image

This crate provides basic imaging processing functions and methods for converting to and from image formats.

lazy_static

https://crates.io/crates/lazy_static

A macro for declaring lazily evaluated statics in Rust.

libloading

https://crates.io/crates/libloading [GitHub]

Safer bindings around system dynamic library loading primitives. The most important safety guarantee by this library is prevention of dangling-Symbols that may occur after a Library is unloaded.

lopdf

https://github.com/J-F-Liu/lopdf

A Rust library for PDF document manipulation.

mundane

https://github.com/google/mundane

Mundane is a Rust cryptography library backed by BoringSSL that is difficult to misuse, ergonomic, and performant (in that order).

openssh

https://crates.io/crates/openssh [GitHub]

Scriptable SSH through OpenSSH in Rust

peg

https://crates.io/crates/peg

rust-peg is a simple yet flexible parser generator that makes it easy to write robust parsers. Based on the Parsing Expression Grammar formalism, it provides a Rust macro that builds a recursive descent parser from a concise definition of the grammar.

pest

https://crates.io/crates/pest

pest is a general purpose parser written in Rust with a focus on accessibility, correctness, and performance. It uses parsing expression grammars (or PEG) as input, which are similar in spirit to regular expressions, but which offer the enhanced expressivity needed to parse complex languages.

pwhash

https://crates.io/crates/pwhash [Github]

A collection of password hashing routines in pure Rust

quiche

https://crates.io/crates/quiche [GitHub]

quiche is an implementation of the QUIC transport protocol and HTTP/3 as specified by the IETF. It provides a low level API for processing QUIC packets and handling connection state. The application is responsible for providing I/O (e.g. sockets handling) as well as an event loop with support for timers.

rand

https://crates.io/crates/rand

A Rust library for random number generation.

regex

https://crates.io/crates/regex

A Rust library for parsing, compiling, and executing regular expressions. Its syntax is similar to Perl-style regular expressions, but lacks a few features like look around and backreferences. In exchange, all searches execute in linear time with respect to the size of the regular expression and search text. Much of the syntax and implementation is inspired by RE2.

reqwest

https://crates.io/crates/reqwest

An ergonomic, batteries-included HTTP Client for Rust.

ring

https://crates.io/crates/ring

Safe, fast, small crypto using Rust

rustfilt

https://crates.io/crates/rustfilt

Demangle Rust symbol names using rustc-demangle. rustfilt works similarly to c++filt, in that it accepts mangled symbol names as command line arguments, and if none are provided it accepts mangled symbols from stdin. Demangled symbols are written to stdout.

Rustls

https://crates.io/crates/rustls

Rustls is a modern TLS library written in Rust. It's pronounced 'rustles'. It uses ring for cryptography and libwebpki for certificate verification.

serde

https://crates.io/crates/serde

Serde is a framework for serializing and deserializing Rust data structures efficiently and generically.

sled

https://crates.io/crates/sled

A (beta) modern embedded database. Doesn't your data deserve a (beta) beautiful new home?

smartcore

https://crates.io/crates/smartcore

SmartCore is a comprehensive library for machine learning and numerical computing. The library provides a set of tools for linear algebra, numerical computing, optimization, and enables a generic, powerful yet still efficient approach to machine learning.

timed

https://github.com/y2kappa/timed

Rust crate to time your function using derive annotations.

  • https://github.com/RustCrypto - Cryptographic algorithms written in pure Rust