Open Source Rust Libraries
Sort By:
Rust Libraries
View 77 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.
-
$300 Free Credits to Build on Google CloudPut your $300 in credit toward real workloads, then keep building with free monthly usage for 20+ products. No commitment and no charge until you upgrade.
-
Veeam Data Platform v13.1 - Get Your Free TrialTry Veeam Data Platform today. Experience the unified platform that's secure by design, portable by default, and proven to recover clean, fast, and anywhere.
-
1
insta
A snapshot testing library for rust
Insta is a snapshot testing library for Rust. It lets developers compare complex values against stored reference outputs instead of writing fragile manual assertions. Snapshot tests are useful when outputs are large, structured, or expected to change during development. The project includes macros for generating snapshots, reviewing changes, and storing inline snapshots inside source files. A companion cargo tool helps manage the review workflow, while a VS Code extension improves snapshot file editing and inspection. Insta is especially useful for command output, serializers, parsers, compilers, debug values, and tests where human review matters. -
2
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. -
3
pdf-inspector
Fast Rust library for PDF inspection, classification
pdf-inspector is a fast Rust library for classifying PDFs and extracting structured text without OCR. It distinguishes text-based, scanned, image-based, and mixed documents while returning confidence scores and pages that may need OCR. Its position-aware parser preserves font data, coordinates, reading order, and multi-column layouts. The converter produces clean Markdown with headings, lists, code blocks, links, page breaks, and formatted tables. It supports CID fonts, several encodings, right-to-left text, and automatic detection of broken font mappings. The same core is available through Rust, Python, Node.js, browser WebAssembly, and command-line interfaces. It is designed for local document pipelines that need fast routing before using slower OCR services. -
4
hyper for Rust
An HTTP library for Rust
hyper is a fast HTTP implementation written in and for Rust. A Client for talking to web services. A Server for building those web services. Blazing fast thanks to Rust. High concurrency with non-blocking sockets. HTTP/1 and HTTP/2 support. hyper is a relatively low-level library, meant to be a building block for libraries and applications. If you are looking for a convenient HTTP client, then you may wish to consider reqwest. If you are looking for a convenient HTTP server, then you may wish to consider warp. Both are built on top of this library. A Service lets you define how to respond to incoming requests. While it is possible to implement the trait directly, there are a few patterns that are common when using Hyper. We’ve included some helpers for when these patterns fit our needs. An echo server will listen for incoming connections and send back the request body as the response body on POST requests. -
Ship Agents FasterGemini Enterprise Agent Platform lets you rapidly build, scale, govern and optimize production-ready agents grounded in your organization's data. The platform enables developers to build custom or pre-built agents for virtually any use case. New customers get $300 in free credits.
-
5
SpaceWasm
A flight-compliant WebAssembly interpreter
SpaceWasm is a NASA JPL WebAssembly interpreter designed for resource-constrained spacecraft systems. It implements a constrained form of the WebAssembly 1.0 specification for executing portable onboard programs. A streaming decoder reads modules in chunks, validates them in one pass, and converts instructions into an interpretation-focused intermediate representation. Its custom memory model uses fixed-size pages to provide deterministic allocation behavior and avoid panic on allocation failure. Embedders can expose controlled host functions while restricting program access, compute time, and system interactions. The project emphasizes sandboxing, portability, predictable resource use, and compatibility with flight-software requirements. Tests, fuzzing, benchmarks, requirements, and integration components are included in the Rust codebase. -
6
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. -
7
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. -
8
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. -
9
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. -
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.
-
10
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! -
11
Sycamore
A library for creating reactive web apps in Rust and WebAssembly
A reactive library for creating web apps in Rust and WebAssembly. Sycamore harnesses the full power of Rust via WebAssembly, giving you full control over performance. Write code that feels natural. Everything is built on reactive primitives without a cumbersome virtual DOM. No JavaScript. Had enough of JavaScript? So have we. Create apps using Sycamore without touching a single line of JS. -
12
winit
Window handling library in pure Rust
Cross-platform window creation and management in Rust. Winit is a window creation and management library. It can create windows and lets you handle events (for example the window being resized, a key being pressed, a mouse movement, etc.) produced by the window. Winit is designed to be a low-level brick in a hierarchy of libraries. Consequently, in order to show something on the window you need to use the platform-specific getters provided by winit, or another library. -
13
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. -
14
Termimad
A library to display rich (Markdown) snippets and texts
Termimad is a Rust library for displaying styled Markdown-inspired content inside command-line and terminal user interfaces. It separates textual structure and data from visual skins so applications can customize presentation cleanly. Supported formatting includes headings, emphasis, code, lists, quotes, tables, horizontal rules, and multiline text. The library handles wrapping, scrolling, table balancing, Unicode, and wide terminal characters. Developers can create reusable skins controlling colors and other terminal styling properties. Safe templates insert dynamic values without accidentally interpreting them as Markdown syntax. Termimad uses Crossterm for terminal behavior and emphasizes precise control without imposing a complete TUI framework. -
15
derive(Error)
derive(Error) for struct and enum error types
This is a Rust crate that provides a convenient derive macro (#[derive(Error)]) for implementing std::error::Error on your custom error types (structs or enums). The goal is to enable library authors to build expressive, typed error types, with readable Display implementations (via #[error("...")] annotations) as well as From conversions (#[from]), source tracking (#[source]), and optionally backtraces. It is designed so that switching from handwritten error implementation to using this error is not a breaking change: you retain the same API. The README shows examples: an enum with variants annotated by #[error("…")] and #[from] fields to derive the appropriate trait impls. The crate expects rustc ≥ 1.68+. The README also outlines how you choose; use thiserror if you care about designing your own error-types (e.g., for libraries) vs anyhow for applications. -
16
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. -
17
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. -
18
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. -
19
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. -
20
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. -
21
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. -
22
Diom
Components platform for robust services
Diom is a backend components platform for building reliable, idiomatic services without repeatedly reimplementing common infrastructure pieces. It provides high-level APIs for service components such as caching, rate limiting, idempotency, queues, and other backend primitives. The project is designed to reduce boilerplate while keeping services robust, predictable, and production-friendly. It runs with zero runtime dependencies and uses its own storage, which makes deployment simpler than stitching together multiple external systems. Diom can operate as a single node or as a highly available cluster, depending on the service requirements. It is useful for backend developers who want reusable infrastructure components with clean APIs and fewer operational moving parts. -
23
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. -
24
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. -
25
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.
