Lib.rs

num_enum

Procedural macros to make inter-operation between primitives and enums easier

ouroboros

Easy, safe self-referential struct generation

recursion

cache-aware stack safe recursion

pinned-init

facilitate safe pinned initialization

alloc-no-stdlib

dynamic allocator that may be used with or without the stdlib. This allows a package with nostd to allocate memory dynamically and be used either with a custom allocator, items on the stack…

field-offset

Safe pointer-to-member implementation

llama-cpp-2

llama.cpp bindings for Rust

safe-transmute

A safeguarded transmute() for Rust

safina

Safe async runtime

tokio-task-pool

Task pool for Tokio Runtime

archmage

Safely invoke your intrinsic power, using the tokens granted to you by the CPU. Cast primitive magics faster than any mage alive.

fastc-lsp

Language Server Protocol implementation for FastC

nrip

Safe rm with a graveyard (MVP: rm, ls, prune, resurrect)

safe-bigmath

non-overflowing, non-panicking numeric types as well as safe big integer and decimal that can scale to any size safely and gracefully, only wasting memory when extra precision is needed

truc

Rust code generator for safe, fixed size, evolving records

dns-server

A threaded DNS server

safe-manually-drop

ManuallyDrop “owned field” pattern with no unsafe, no .unwrap()s, no macros

cadical-sys

Almost complete safe and unsafe bindings for the CaDiCal SAT solver. Made using the cxx crate and then wrapped in a safe 1 to 1 API.

hlist2

Compile-time heterogeneous list implementation

safe_unzip

Secure zip extraction. Prevents Zip Slip and Zip Bombs.

prudent

Help you make Rust code safer. For both authors and reviewers.

alloc-stdlib

A dynamic allocator example that may be used with the stdlib

rustix-openpty

Safe Rust bindings to openpty and related functions

gc-arena

safe, incrementally garbage collected arenas

env

std::env::{set_var, remove_var} safely

xldenis/creusot-contracts

contracts and logic helpers for Creusot

safe-lock

A lock struct with a const fn constructor and no unsafe - ARCHIVED

memmap3

Safe, zero-copy memory-mapped I/O. Drop-in replacement for memmap2 with persistent structs and zero unsafe in user code.

sscli

Agent-friendly token efficient SQL Server CLI tool for database inspection

sai-cli

('sai') — Tell the shell what you want, not how to do it. Natural-language to safe shell command generator.

magetypes

Token-gated SIMD types with natural operators. Depends on archmage for tokens.

lv2

A safe, fast, and ergonomic framework to create LV2 plugins

biscuit-converter

A decimal ASCII parser

shinkai_tools_runner

execute shinkai-tools in a safe and performant environment

ftui-simd

Optional safe SIMD-friendly optimizations for FrankenTUI

deploy-temp-fringe

safe, lightweight userland context switches

llama-cpp-4

llama.cpp bindings for Rust

winix

Unix syscalls on Wine

cooked-waker

A safe interface for creating async Wakers

builder-relayer-client-rust

Builder + Relayer client utilities: build, sign and submit transactions for Gnosis Safe/Builder workflows used by Polymarket

wirefox

Protobuf Runtime

rust-xfinal

A safe and simplely used web server framework

zfi

Zero-cost and safe interface to UEFI firmware

llvm-lib

LLVM library with safe and flexibility in mind, without over complexity based on LLVM-C API

epanet-rs

A fast, modern and safe re-implementation of the EPANET2 hydraulic solver, written in Rust

atomicbox

Safe atomic pointers to boxed data

windows-wrappers

A collection of safe wrappers for the windows-rs crate

libh3

Safe Rust Bindings to Uber's Hexagonal Hierarchical Spatial Index - H3

yamp

Minimal Parser - A safe, predictable YAML parser that treats all values as strings

safina-timer

Safe async timers - ARCHIVED: Code moved to safina crate

hanzo-runner

execute hanzo-tools in a safe and performant environment

safe_arith

Safe arithmetic on integers, which avoids overflow and division by zero

safina-executor

Safe async runtime executor - ARCHIVED: Code moved to safina crate

safina-async-test

Macro for running async tests - ARCHIVED: Code moved to safina crate

dyn_safe

Take control of the Semver hazard of the dyn safety of your traits!

fastc

A safe C-like language that compiles to C11

wartcl

A minimal embeddable Tcl-like language

stackalloc

Safely allocate and manipulate arbitrarily-sized slices on the stack at runtime

hanzo-tools-runner

execute hanzo-tools in a safe and performant environment

voladdress

easy volatile memory abstraction

rustix-libc-wrappers

Safe Rust bindings to libc functions

safina-sync

Safe structs for sharing or sending data between async tasks - ARCHIVED: Code moved to safina crate

unsync-pipe

Ringbuffer-backed !Send !Sync binary safe repr(C) AsyncWrite/AsyncRead pair

safecast

Traits to define safe casting between types

safina-threadpool

Safe thread pool - ARCHIVED: Code moved to safina crate

safina-net

Safe async network functions - ARCHIVED: Code moved to safina crate

kul

Parser for a unique textual notation that can be used as both a data format and a markup language and that has powerful extensibility of both lexical syntax and semantics. Inspired…

wavecraft-metering

Real-time safe SPSC metering for Wavecraft audio plugins

jinko

safe, small and fast programming language with Rust interoperability

ponsic-winsafe

The dependency of the ponsic crate

safe-rm-hehe

Một công cụ thay thế lệnh rm, giúp đưa file vào thùng rác thay vì xóa vĩnh viễn

disjoint

Fast and safe implementation of the disjoint-set data structure

soft-ascii-string

char/str/string wrappers which add a "is-ascii" soft constraint

ps-alloc

a reasonably safe allocator

windows-services

Windows services

misfortunate

Perverse implementations of safe Rust traits

postgres-parser

An llvm-based safe wrapper for PostgresSQL's query parser. Currently based on v13

safina-select

Safe async select function, for awaiting multiple futures - ARCHIVED: Code moved to safina crate

xj_ctime

Small library to bridge libc's time API into safe Rust for machine translations

pinlist

a safe and easy version of intrusive linked lists

better-refcell

A drop-in replacement for RefCell with safe unborrow and reborrow capabilities

foreign_vec

Unofficial implementation of Apache Arrow spec in safe Rust

static-queue

A statically sized, no_std, allocation-free, safe Rust queue implemented as a ring buffer with full test coverage

tracing-perfetto-sdk-sys

Native C++ bindings for the Perfetto SDK used by tracing-perfetto-sdk

bitbound

safe, efficient array access with compile time boundary protection

sharded

Safe, fast, and obvious concurrent collections

real_parent

Symlink-safe path extension for parent directory

cell-gc

A fun garbage collector for that virtual machine you're writing in Rust

lx

A no_std crate to use Linux system calls

ref_kind

Different reference kinds

poolio

A thread-pool

maybe-uninit-ext

Extended maybe-uninit types

flexcell

A flexible cell that allows safe circumvention of double borrow issues

rustsynth

Safe VapourSynth wrapper

uninit_buffers

Safe uninitialized buffers that take input from functions or iterators

dicoco_safe_math

simplified safe math operations

nvm_rs

that provides the nvm! macro to run safe code within unsafe blocks

unit-rs

A safe wrapper around NGINX Unit's libunit

recursion-visualize

visualized cache-aware stack safe recursion

recursion-schemes

cache-aware stack safe recursion (this is the really haskell brained one)

gc-sequence

a system for encoding safe points for computations running on gc-arena

safe_unwrap

allows unwrapping and annotating that the unwrap will never fail. Does not require std.

secured_linked_list

A cryptographically secured and provable linked list

async-safe-defer

Minimal async- and sync-capable defer crate

backroll

A pure Rust async implementation of GGPO

xcb-util-cursor-sys

Bindings to libxcb-cursor

winpty-rs-windows-services

Windows services

llvm_quick

Rust's wrapper for llvm

zipwhip-rs

A fast, asynchronous, and safe wrapper around the Zipwhip API

gnu-libjit

A safe rust wrapper around the libjit just in time compiler

rm-improved

rip: a safe and ergonomic alternative to rm

trm

Temporary rm. A safer alternative to rm.

cismute

Safely transmute type to itself in generic contexts

siphash_c_d

A no-std, safe, generic implementation of the siphash_c_d algorithm

totally-safe

that allows you to bypass Rust's safety guarantees with totally safe patterns, featuring arbitrary lifetimes, aliasing, and more!

safe-write

A safe file writing utility

tink-ffi-sys

Raw FFI bindings to Google Tink via C shim

safe_uri

safe URI types

taitank-safe

taitank in safe rust

safehttp

A slow (but simple, safe and strict) HTTP/1.1 parser

safe-discriminant

A minimalistic, no_std compatible trait and procedural macro for extracting discriminants from enums at zero cost

ref-portals

Safely use (stack) references outside their original scope

petri-nets

safe and efficient library wrapper for simulating a minimal form of petri nets

lemonlang

an experimental, modern, purely safe, programming language

object-safe

Implement object-unsafe traits for trait objects

web30

Async endian safe web3 library

lvgl-codegen

Code generation based on LVGL source code

safe_http

safe HTTP types

gdbm

Safe wrapper for gdbm-sys bindings

bolts

A fast, safe, powerful web framework based on the principle of least confusion and sane defaults

tablesalt

A safe, oxidized wrapper for libsodium

dyn_formatting

limited Python-style safe dynamic (runtime) formatting support for Rust

mapstruct

Create refactor safe derivatives of Structs with proc-macros

simple-safe

managing a password database

xkbcommon-rs-codegen

codegen for the xkbcommon-rs crate. Not meant as a standalone crate

resize_slice2

Resize a slice given a larger slice in safe Rust

fake-enum

creating FFI safe "fake" enum types

hnews

Hacker News API, synchronous and lightweight, thanks to ureq and miniserde!

webgl-rs

Safe Rust wrapper around the WebGL API

justly

justified containers

rust-salsa20

Fast implementation of salsa20 in safe rust

projections

Macro-free pin projections because why not?

alloc-safe

Safe memory allocation, no panic!

shared_bytes

Owned string and byte slices

safevalue

A value based approach to uphold SAFETY requirements for unsafe Rust code

to_that

Declarative compile safe explict type conversion. Useful for chaining.

alias-ptr

(Mostly) safe manually-freed shared pointers in Rust

fast-lru

A fast, 100% safe, stack based LRU cache

pinned-init-macro

Proc macros for the pinned-init crate

safe_ecs

ECS written in safe code

keybinder

Rust wrapper for Keybinder

abox

A safe wrapper around AtomicPtr

cpq

A Concurrent Priority Queue implemented in Safe Rust

jajajvm

A safe JVM without any dependency and is so simple, it could put a smile on your face

safe_uri_ext

Extra URI functionality like parse and display for the safe_uri crate

anysafe

any safe

oppai-rs

Rust bindings to oppai-ng(https://github.com/Francesco149/oppai-ng) with a safe wrapper

safe_cell

Safer than std::cell::UnsafeCell!

voltlane-net

Networking library for Voltlane, providing connection management and communication protocols

sports

a list of ports to scan, fast、smar and safe

pluginop-rawptr

Safe abstractions atop raw pointers

safe-fork

A tiny library providing fork to safe Rust

safe

A #[safe] attribute for explaining why unsafe { ... } is OK.

bitvec_padded

Bit vector struct that includes byte padding for safe serialization and deserialization

geometry-box

Point, Size and u128 boxes that are safe to pass over ffi

essential-lock

A minimal crate containing Essential's locking method that is safe to use in async code

wireguard-embeddable

embeddable wireguard library that wraps the C implementation by Jason Donfeld. Allows interacting with the kernel-land wireguard native implementation from Rust to create, modify, delete…

ts-mem-pool

thread-safe memory pool crate

saferm

wrapper around rm that prevents you from accidentally deleting files

shortid

uuidv1 generator and variant. safe and fast.

madvise

Rustic safe wrapper around unix madvise

salloc

Safe C-like memory allocator for windows

ringbahn

an experimental safe API for io-uring

acl-rs

A safe rust wrapper around the acl-sys crate

reduce_unsafe

Reduce unsafe code and detect soundness bugs with equivalence checks against safe code

scicrypt-numbertheory

A scicrypt crate implementing number theoretic algorithms such as random (safe) prime generation

csq

A Concurrent Set Queue implemented in Safe Rust

safetruct

droper

lifetime-extender

published for a severe bug that allow user write safe code to extend the lifetime of any object, which is unacceptable since such behavior may easily leads to UAF, double free and many UB…

sn_dbc

Safe Network DBC

safe-graph

Graph implementation (refactored version of GraphMap from popular crate petgraph)

pid_control

A PID controller library

safe-tensors-export