Open Source Rust Libraries
Sort By:
Rust Libraries
View 74 business solutionsBrowse free open source Rust Libraries and projects below. Use the toggles on the left to filter open source Rust Libraries by OS, license, language, programming language, and project status.
-
MongoDB Atlas runs apps anywhereMongoDB Atlas gives you the freedom to build and run modern applications anywhere—across AWS, Azure, and Google Cloud. With global availability in over 115 regions, Atlas lets you deploy close to your users, meet compliance needs, and scale with confidence across any geography.
-
Go From AI Idea to AI App FastAccess Gemini 3 and 200+ models. Build chatbots, agents, or custom models with built-in monitoring and scaling.
-
1
RustDesk Server Program
Self-host your own RustDesk server
rustdesk-server is the self-hosted backend for RustDesk, an open-source remote desktop solution. It provides the rendezvous and relay components that allow RustDesk clients to discover peers and traverse NATs securely, enabling direct or relayed connections when needed. By running your own server, you retain control over connection metadata and can operate entirely within your organization’s perimeter. The project targets simplicity of deployment while maintaining performance characteristics suitable for interactive screen sharing and file transfer. It supports common operational needs such as configuring ports, authentication modes, and relay behavior to match diverse network constraints. Together with RustDesk clients, it offers a fully open alternative to proprietary remote-access ecosystems with an emphasis on privacy and self-custody. -
2
Rust Programming Language
Empowering everyone to build reliable and efficient software
The Rust Programming Language is a language that empowers you to build reliable and efficient software. It runs blazingly fast and is memory-efficient, so it can power performance-critical services and run on embedded devices. It has a rich type system and ownership model, ensuring both thread and memory safety. Consisting of a standard library, great documentation and a friendly compiler, plus a top-notch build tool, package manager, auto-formatter and many other great tools, it’s the language of choice for increased productivity. Hundreds of companies the world over are using Rust to power an amazing range of cross-platform solutions. See what a great fit Rust can be for your own projects! -
3
RuVector
Self-Learning, Vector Graph Neural Network, and Database built in Rust
RuVector is part of the broader rUv ecosystem of AI engineering tools and focuses on enabling advanced vector-based processing and intelligent system development within agentic and AI-driven pipelines. The project fits into a larger vision of modular, composable AI infrastructure designed to support autonomous agents, data retrieval, and intelligent automation workflows. It emphasizes extensibility and interoperability with modern AI stacks, allowing developers to integrate vector operations into search, reasoning, or generative systems. The repository reflects a research-forward approach that blends practical utilities with experimental agentic concepts, encouraging exploration of emerging AI design patterns. It is intended for developers building sophisticated AI-powered applications who need flexible vector handling and integration capabilities. -
4
Ansible Examples
A few starter examples of ansible playbooks, to show features
This repository collects practical, real-world examples of using Ansible to automate infrastructure, deployments, and configurations. Each directory demonstrates a specific use case—ranging from setting up web servers, load balancers, and databases to orchestrating multi-tier applications in cloud environments. The examples highlight common Ansible practices such as organizing inventories, writing reusable playbooks, using roles, and handling variables and templates. They’re designed to be adapted directly into your own infrastructure or to serve as reference blueprints when learning how to structure automation projects. Whether you’re managing a handful of servers or deploying at scale, this repo provides starting points that illustrate how Ansible can streamline repetitive operational tasks. -
Custom VMs From 1 to 96 vCPUs With 99.95% UptimeLive migration and automatic failover keep workloads online through maintenance. One free e2-micro VM every month.
-
5
CXX
Safe interop between Rust and C++
CXX is a library that offers safe interop between Rust and C++. It provides a safe mechanism for calling C++ code from Rust and vice versa, one that is protected from the many possible things that can go wrong when bindgen or cbindgen is used to generate unsafe C-style bindings. The general idea of CXX is to define the signatures of both sides of the FFI boundary embedded together in one Rust module. CXX gets a complete picture from this of the boundary, and through it is able to perform static analyses against the types and function signatures, ensuring that both Rust's and C++'s invariants and requirements are upheld. CXX then emits the relevant extern "C" signatures on both sides through a pair of code generators. This is done together with any necessary static assertions needed for later in the build process to verify correctness. The result is an FFI bridge that operates at zero or negligible overhead, with no copying, serialization or memory allocation needed. -
6
Mako
An extremely fast, production-grade web bundler based on Rust
Mako is a new web bundler for web apps, libraries, and frameworks. It's designed to be fast, reliable, and easy to use. It has been used in hundreds of projects in production by Ant Group, and other companies. If you are looking for a modern web bundler, Mako is the right choice. -
7
Ruma
A set of Rust crates for interacting with the Matrix chat network
Matrix is an open specification for an online communication protocol. It includes all the features you'd expect from a modern chat platform including instant messaging, group chats, audio and video calls, searchable message history, synchronization across all your devices, and end-to-end encryption. Matrix is federated, so no single company controls the system or your data. You can use an existing server you trust or run your own, and the servers synchronize messages seamlessly. Learn more in the Introduction to Matrix. Rust is a systems programming language from Mozilla built with safety, concurrency, and performance in mind. Its novel approach to memory safety and its rich type system make it an excellent choice for writing fast, secure, and reliable programs. -
8
mdBook
Create books from markdown files
mdBook is a command line tool and Rust crate to create books with Markdown. The output resembles tools like Gitbook, and is ideal for creating product or API documentation, tutorials, course materials or anything that requires a clean, easily navigable and customizable presentation. mdBook is written in Rust; its performance and simplicity made it ideal for use as a tool to publish directly to hosted websites such as GitHub Pages via automation. This guide, in fact, serves as both the mdBook documentation and a fine example of what mdBook produces. mdBook includes built in support for both preprocessing your Markdown and alternative renderers for producing formats other than HTML. These facilities also enable other functionality such as validation. Searching Rust's crates.io is a great way to discover more extensions. -
9
Polars
Dataframes powered by a multithreaded, vectorized query engine
Polars is a high-performance, multi-language DataFrame library built in Rust using Apache Arrow. It delivers blazing-fast, vectorized, and parallel data manipulation with both eager and lazy execution, making it an excellent tool for data processing in Python, Rust, Node.js, R, and SQL contexts. -
Our Free Plans just got better! | Auth0You asked, we delivered! Auth0 is excited to expand our Free and Paid plans to include more options so you can focus on building, deploying, and scaling applications without having to worry about your security. Auth0 now, thank yourself later.
-
10
mail-parser
Fast and robust e-mail parsing library for Rust
Stalwart Mail Parser is a high-performance Rust library designed for parsing and analyzing email messages. It efficiently handles complex MIME structures, supports various encodings, and is optimized for speed and robustness. The library is suitable for applications requiring detailed email processing and analysis. -
11
Anyhow
Flexible concrete Error type built on std::error::Error
This is a Rust library (crate) that provides a flexible, concrete error type built atop the standard std::error::Error trait. Its primary goal is to make error handling in applications easy: instead of defining lots of custom error types, you can use anyhow::Error (or the alias anyhow::Result<T>) for fallible functions. The crate supports attaching context to errors, so you can convert a low-level error (like “file not found”) into one with richer diagnostics (“Failed to read instructions from path X”) using .context() or .with_context(). It supports downcasting (so you can inspect the underlying error type), and for recent versions of Rust, it will capture backtraces by default when the underlying error type doesn’t already. It also supports no_std mode (in limited form) by disabling default features. The README distinguishes it from library-oriented error crates (like thiserror): use anyhow when you just care about application-level error handling, not fine-grained types. -
12
Chumsky
Write expressive, high-performance parsers with ease.
Chumsky is a parser library for Rust that focuses on expressiveness and performance. It provides developers with tools to write high-performance parsers using combinators, suitable for a wide range of parsing tasks. -
13
DCV Color Primitives
DCV Color Primitives Library
DCV Color Primitives is a library to perform image color model conversion. Aware of the underlying hardware and supplemental cpu extension sets (up to avx2). Support data coming from a single buffer or coming from multiple image planes. Support non-tightly packed data. Support images greater than 4GB (64 bit). Convert an image from bgra to nv12 (single plane) format containing yuv in BT601. You might want to propagate errors to the caller function or mix with some other error types. So far, buffers were sized taking into account the image pixel format and dimensions; However, you can use a function to compute how many bytes are needed to store an image of a given format and size. If your data is scattered in multiple buffers that are not necessarily contiguous, you can provide image planes. To take into account data which is not tightly packed, you can provide image strides. -
14
Floem
A native Rust UI library with fine-grained reactivity
Floem is a cross-platform GUI framework for Rust. It aims to be extremely performant while providing world-class developer ergonomics. Supporting both GPU and CPU rendering, Floem gives you performance that's closest to bare metal. Also primitives are provided to help the developer to write performant UI code without too much effect. -
15
GraphQL Juniper
GraphQL server library for Rust
GraphQL is a data query language developed by Facebook intended to serve mobile and web application frontends. 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. Juniper does not include a web server - instead it provides building blocks to make integration with existing servers straightforward. It optionally provides a pre-built integration for the Actix, Hyper, Iron, Rocket, and Warp frameworks, including embedded Graphiql and GraphQL Playground for easy debugging. The best place to get started is the Juniper Book, which contains guides with plenty of examples, covering all features of Juniper. Juniper supports the full GraphQL query language according to the specification (October 2021), including interfaces, unions, schema introspection, and validations. It can also output the schema in the GraphQL Schema Language. -
16
Iced
A cross-platform GUI library for Rust, inspired by Elm
Iced is a cross-platform, end-user-oriented GUI library for Rust, inspired by The Elm Architecture. It expects you to split user interfaces into four different concepts, which are: the state of your app; messages, which are user interactions or other meaningful events; view logic, which displays your state as widgets that can result in messages; and update logic, which offers a way to update your state and react to messages. Iced is very simple and easy to use, and is type-safe. It offers many great features including built-in widgets and custom widget support, debug overlay, a modular ecosystem and more. -
17
Kameo
Fault-tolerant Async Actors Built on Tokio
Kameo is a lightweight Rust library for building fault-tolerant, distributed, and asynchronous actors. It allows seamless communication between actors across nodes, providing scalability, backpressure, and panic recovery for robust distributed systems. Kameo stands out by offering simplicity, resilience, and scalability. It's not just about making concurrent programming easier—it's about empowering you to build the reliable, efficient, and scalable systems that today's users demand. Whether you're a seasoned developer or just starting out, Kameo is designed to be relatable and accessible, providing you with the tools you need to bring your ideas to life. -
18
LiteBox
A security-focused library OS supporting kernel execution
LiteBox is a security-focused “library OS” sandboxing project that aims to shrink the interface between an application and its host environment to reduce attack surface. Instead of relying solely on broad OS-level permissions, it focuses on isolating workloads by tightly controlling the boundary where code interacts with host services and system resources. The design emphasizes interoperability across different integration layers, describing a separation between “North” shims (how apps or runtimes plug in) and “South” platforms (where the sandbox runs), which helps the system adapt to multiple deployment contexts. A key aspect of the project is that it targets both kernel-mode and user-mode scenarios, enabling experimentation with different trust and performance tradeoffs. The repository positions LiteBox as a foundation for building hardened execution environments where untrusted or semi-trusted components can run with reduced privileges and a minimized host interface. -
19
Mundane
Mundane is a Rust cryptography library backed by BoringSSL
Mundane is a Rust cryptography library designed to be safe, ergonomic, and high-performance, with its cryptographic operations powered by BoringSSL. It aims to eliminate common security pitfalls by providing APIs that are intentionally difficult to misuse, prioritizing safety and correctness over flexibility. The library vendors its own copy of BoringSSL, ensuring consistent builds without external dependencies and avoiding symbol conflicts between different versions. Mundane emphasizes clarity in its cryptographic abstractions, making it accessible to developers while maintaining robust security guarantees. It is ideal for projects that need reliable, production-grade cryptography built directly on top of proven, well-tested C libraries. -
20
Nitro Secure Module library
Provides Nitro Enclaves with attestation capability
This provides a library for interacting with the Nitro Secure Module, which provides Nitro Enclaves with attestation capability. This is a collection of helpers which Nitro Enclaves userland applications can use to communicate with a connected NitroSecureModule (NSM) device. Various operations can be requested such as PCR query and manipulation, attestation, entropy. -
21
Ollama-rs
A simple and easy-to-use library for interacting with the Ollama API
Ollama-rs is a Rust library designed to provide a simple and efficient interface for interacting with the Ollama API, enabling developers to integrate local large language models into Rust applications. It follows the official Ollama API closely, ensuring compatibility while offering an idiomatic Rust experience with strong typing and asynchronous execution. The library supports a wide range of operations, including text generation, chat interactions, embeddings, and model management, making it suitable for both simple applications and more advanced AI workflows. It includes streaming capabilities for real-time output, allowing developers to process responses incrementally rather than waiting for full completions. The project also introduces support for tool calling and custom function integration, enabling more dynamic and agent-like behavior within applications. -
22
Parser for Rust source code
Parser for Rust source code
Parser for Rust source code is a major Rust crate for parsing Rust source code (token streams) into a syntax tree (AST) that procedural macros can inspect or transform. The primary target is macro authors: you can parse TokenStreams into syn::File, syn::Item, syn::Expr, syn::Type, etc. It offers rich data structures, fine-grained parsing, span tracking (for error reporting), traversal and mutation APIs (visit, fold, visit_mut), printing back to tokens, and strong feature-gating so you only compile what you need. The documentation emphasises that while the crate is geared for procedural macros (and custom derives), some of the APIs may be of more general use. Using syn you can effectively write code that analyzes or generates Rust code at compile time. -
23
Peroxide
Rust numeric library with high performance and friendly syntax
Rust numeric library contains linear algebra, numerical analysis, statistics and machine learning tools with R, MATLAB, Python-like macros. Peroxide uses a 1D data structure to represent matrices, making it straightforward to integrate with BLAS (Basic Linear Algebra Subprograms). This means that Peroxide can guarantee excellent performance for linear algebraic computations by leveraging the optimized routines provided by BLAS. For users familiar with numerical computing libraries like NumPy, MATLAB, or R, Rust's syntax might seem unfamiliar at first. This can make it more challenging to learn and use Rust libraries that heavily rely on Rust's unique features and syntax. -
24
PgRx
Build Postgres Extensions with Rust
pgrx is a Rust framework for developing PostgreSQL extensions, making it easier to write safe, high-performance native extensions in Rust. It handles the boilerplate and unsafe FFI needed to interface with Postgres internals, allowing developers to focus on logic. With built-in support for SQL generation, testing, and deployment, pgrx streamlines the extension creation process while embracing Rust’s safety guarantees. -
25
Pom
PEG parser combinators using operator overloading without macros
pom is a parser combinator library in Rust, utilizing operator overloading to build parsers in a modular and readable way. It facilitates the construction of complex parsers without macros.
