The trust-minimized, zero-knowledge bridging protocol, designed for censorship resistance, extremely high security, and usage in decentralized finance.

Fuel Network Rust SDK

Extremely fast Query Engine for DataFrames, written in Rust

Fullstack app framework for web, desktop, and mobile.

Rust / Wasm framework for creating reliable and efficient web applications

A runtime for writing reliable asynchronous applications with Rust. Provides I/O, networking, scheduling, timers, ...

A toolchain for web projects, aimed to provide functionalities to maintain them. Biome offers formatter and linter, usable via CLI and LSP.

Development at the speed of light

Actix Web is a powerful, pragmatic, and extremely fast web framework for Rust.

A Rust crate for cooking up terminal user interfaces (TUIs) 👨‍🍳🐀 https://ratatui.rs

The GitButler version control client, backed by Git, powered by Tauri/Rust/Svelte

Build fast web applications with Rust.

🚀 Fast, secure, lightweight containers based on WebAssembly

A cross-platform, safe, pure-Rust graphics API.

🧰 The Rust SQL Toolkit. An async, pure Rust SQL crate featuring compile-time checked queries without a DSL. Supports PostgreSQL, MySQL, and SQLite.

Diem’s mission is to build a trusted and innovative financial network that empowers people and businesses around the world.

A full featured, fast Command Line Argument Parser for Rust

Fast Rust-based bundler for the web with a modernized webpack API 🦀

A native gRPC client & server implementation with async/await support.

An idiomatic, lean, fast & safe pure Rust implementation of Git

TensorZero is an open-source LLMOps platform that unifies an LLM gateway, observability, evaluation, optimization, and experimentation.

Serialization framework for Rust

A data-first Rust-native UI design toolkit.

A framework for building compiled Node.js add-ons in Rust via Node-API

⚙️🦀 Build modular and scalable LLM Applications in Rust

Boa is an embeddable Javascript engine written in Rust.

Safe interop between Rust and C++

Application level tracing for Rust.

Flexible concrete Error type built on std::error::Error

Aptos is a layer 1 blockchain built to support the widespread use of blockchain through better technology and user experience.

The framework for building with WebAssembly (wasm). Easily & securely load wasm modules, move data, call functions, and build extensible apps.

Strongly typed JSON library for Rust

Lore is a next-generation, open source version control system

derive(Error) for struct and enum error types

Rhai - An embedded scripting language for Rust.

A Language Server for Postgres

Readyset is a MySQL and Postgres wire-compatible caching layer that sits in front of existing databases to speed up queries and horizontally scale read throughput. Under the hood, ReadySet caches the results of cached select statements and incrementally updates these results over time as the underlying data changes.

🦀 event stream processing for developers to collect and transform data in motion to power responsive data intensive applications.

Safe Rust bridge for creating Erlang NIF functions

Build Postgres Extensions with Rust!

a multi-language bindings generator for rust

Build system, successor to Buck

Rust bindings for the V8 JavaScript engine

Rust Kubernetes client and controller runtime

Write Cloudflare Workers in 100% Rust via WebAssembly

Create ridiculously fast Lexers

GlueSQL is quite sticky. It sticks to anything.

A generic framework for on-demand, incrementalized computation. Inspired by adapton, glimmer, and rustc's query system.

A query engine for any combination of data sources. Query your files and APIs as if they were databases!

A debugging toolset and library for debugging embedded ARM and RISC-V targets on a separate host

The Parity Polkadot Blockchain SDK

High level Lua 5.5/5.4/5.3/5.2/5.1 (including LuaJIT) and Luau bindings to Rust with async/await support

cuda-oxide is an experimental Rust-to-CUDA compiler that lets you write (SIMT) GPU kernels in safe(ish), idiomatic Rust. It compiles standard Rust code directly to PTX — no DSLs, no foreign language bindings, just Rust.

An async ORM for Rust

Reference client for NEAR Protocol

Rust reflection, serialization, deserialization, pretty printing, etc. — the last proc macro you should need

Build frontend browser apps with Rust + WebAssembly. Supports server side rendering.

An embeddable dynamic programming language for Rust.

Multi-platform high-performance compute language extension for Rust.

Compile time static maps for Rust

Type erasure for async trait methods

rust wrapper for rocksdb

Rust cache structures and easy function memoization

A modular toolkit for building fast, reliable Web applications and libraries with Rust and WASM

rust raft with improvements

A vector indexing library to bring fast, fresh and filtered search to your database

🔱 A dynamic SQL query builder for MySQL, Postgres and SQLite

Rust keyboard firmware library with layers, macros, real-time keymap editing, wireless(BLE) and split support

Communication infrastructure for the AI era — one binary, one broker, one storage layer, any protocol

Rusty wrapper for the Unified Extensible Firmware Interface (UEFI). This crate makes it easy to develop Rust software that leverages safe, convenient, and performant abstractions for UEFI functionality.

TFHE-rs: A Pure Rust implementation of the TFHE Scheme for Boolean and Integer Arithmetics Over Encrypted Data.

Golem Cloud is the agent-native platform for building AI agents and distributed applications that never lose state, never duplicate work, and never require you to build infrastructure.

🚀 The open-source, multi-tenant platform for self-building knowledge graphs and simulation

Rust quasi-quoting

Polkadot's ink! to write smart contracts.

The current, performant & industrial strength version of Holochain on Rust.

Copper is an operating system for robots - build, run, and replay your entire robot deterministically.

Noir is a domain specific language for zero knowledge proofs

Date and time handling in Rust.

Efficient, deferred formatting for logging on embedded systems

expose REST APIs from a Rust program

DragonOS is an operating system developed from scratch using Rust, with Linux compatibility. It is designed for **Serverless** scenarios. 使用Rust从0自研内核，具有Linux兼容性的操作系统，面向云计算Serverless场景而设计。

Ariel OS is a library operating system for secure, memory-safe, low-power Internet of Things, written in Rust

A fast RFC6455 WebSocket implementation

modular service framework to move and transform network packets

Link-time initialization, destruction, scattered data collection macros for Rust

High-performance, well-tested & documented core libraries for Ethereum, in Rust

The Rust web framework for lazy developers.

compiler from JSON Schema into idiomatic Rust types

Hierarchical state machines for designing event-driven systems

log analysis tool

Asynchronous streams for Rust using async & await notation

STARK-based virtual machine

Extremely fast tracing library for Rust

Firefox Application Services

cuTile Rust provides a safe, tile-based kernel programming DSL for the Rust programming language. It features a safe host-side API for passing tensors to asynchronously executed kernel functions.

Rust implementation of the Matter protocol.

Omicron: Oxide control plane

Patina Firmware

Declarative secrets, every environment, any provider.