num_enum
Procedural macros to make inter-operation between primitives and enums easier
ouroboros
Easy, safe self-referential struct generation
alloc-stdlib
A dynamic allocator example that may be used with the stdlib
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…
recursion
cache-aware stack safe recursion
archmage
Safely invoke your intrinsic power, using the tokens granted to you by the CPU. Cast primitive magics faster than any mage alive.
pwd-grp
Access Unix passwords and groups
gc-arena
safe, incrementally garbage collected arenas
noyalib
A pure Rust YAML library with zero unsafe code and full serde integration
vibe-style
Style checker with Rust syntax and semantic analysis, plus first-batch Swift checks and safe deterministic fixes
field-offset
Safe pointer-to-member implementation
safe-transmute
A safeguarded transmute() for Rust
stackalloc
Safely allocate and manipulate arbitrarily-sized slices on the stack at runtime
safina
Safe async runtime
magetypes
Token-gated SIMD types with natural operators. Depends on archmage for tokens.
mft
A Fast (and safe) parser for the Windows Master File Table (MFT) format
tokio-task-pool
Task pool for Tokio Runtime
deepmesa-collections
A collection of data structures and algorithms designed for performance
piot-fixture-zzz-poly-rust
Put It Out There canary fixture. Safe to ignore.
index_type
Type-safe newtype indices for Rust
rustix-openpty
Safe Rust bindings to
openptyand related functions
safe-manually-drop
ManuallyDrop“owned field” pattern with nounsafe, no.unwrap()s, no macros
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
vulkan-rust
Ergonomic Vulkan bindings for Rust, generated from vk.xml
mssf-core
Azure Service Fabric. Rust safe APIs.
dns-server
A threaded DNS server
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.
truc
Rust code generator for safe, fixed size, evolving records
drm-ffi
Safe, low-level bindings to the Direct Rendering Manager API
xldenis/creusot-contracts
contracts and logic helpers for Creusot
nrip
Safe rm with a graveyard (MVP: rm, ls, prune, resurrect)
safe_unzip
Secure zip extraction. Prevents Zip Slip and Zip Bombs.
cooked-waker
A safe interface for creating async Wakers
zmanager-libarchive
Safe, narrow read-side libarchive wrapper used by zmanager-core and zmanager-cli
cuda-core
Idiomatic CUDA API
prudent
Help you make Rust code safer. For both authors and reviewers.
bsql
Safe SQL for Rust — if it compiles, the SQL is correct
deploy-temp-fringe
safe, lightweight userland context switches
hlist2
Compile-time heterogeneous list implementation
poolio
A thread pool
liblbfgs
Fast and safe Rust implementation of LBFGS and OWL-QN algorithms ported from Naoaki Okazaki's C library libLBFGS
memmap3
Safe, zero-copy memory-mapped I/O. Drop-in replacement for memmap2 with persistent structs and zero unsafe in user code.
safe-allocator-api
A safe wrapper around the
allocator_api’s Allocator trait
hanzo-runner
execute hanzo-tools in a safe and performant environment
lv2
A safe, fast, and ergonomic framework to create LV2 plugins
zstd-sys-rs
Rust bindings to statically linked zstd v1.5.7, with a safe zero-copy (de)compress API
pin-list
A safe
Pin-based intrusive doubly linked list
hanzo-tools-runner
execute hanzo-tools in a safe and performant environment
disjoint
Fast and safe implementation of the disjoint-set data structure
zfi
Zero-cost and safe interface to UEFI firmware
windows-wrappers
A collection of safe wrappers for the windows-rs crate
safevalue
A value based approach to uphold SAFETY requirements for unsafe Rust code
env
std::env::{set_var, remove_var} safely
geometry-box
Point, Size and u128 boxes that are safe to pass over ffi
atomicbox
Safe atomic pointers to boxed data
safe-lock
A lock struct with a
const fnconstructor and nounsafe- ARCHIVED
tracing-rc
Cycle-aware reference-counted pointers with a safe, simple api
bekoedit-fs
Workspace scoping, file tree index, safe file operations, atomic save, and recovery snapshots for bekoedit
tracing-perfetto-sdk-sys
Native C++ bindings for the Perfetto SDK used by tracing-perfetto-sdk
sai-cli
('sai') — Tell the shell what you want, not how to do it. Natural-language to safe shell command generator.
ottavino-gc-arena
safe, incrementally garbage collected arenas (updated fork of gc-arena)
libassist-sys
Raw FFI bindings and safe RAII wrappers for the ASSIST ephemeris-driven N-body integrator
tailvore
Easy, safe self-referential struct generation
aidens-tool-kit
Tool registry, exposure planning, and safe sandbox-validated dispatch
windows-services
Windows services
shinkai_tools_runner
execute shinkai-tools in a safe and performant environment
voladdress
easy volatile memory abstraction
wirefox
Protobuf Runtime
safina-timer
Safe async timers - ARCHIVED: Code moved to
safinacrate
fringe
safe, lightweight userland context switches
wavecraft-metering
Real-time safe SPSC metering for Wavecraft audio plugins
mcp-fundraise
MCP server for startup fundraising — SAFE conversion, dilution modeling, valuation, runway, YC company search, SEC filings, investor pipeline
rust-xfinal
A safe and simplely used web server framework
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…
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…
librebound-sys
Raw FFI bindings and safe RAII wrappers for the REBOUND N-body integrator
safina-executor
Safe async runtime executor - ARCHIVED: Code moved to
safinacrate
lua-cli
The lua-rs command-line interpreter: Lua 5.4 in safe Rust
jinko
safe, small and fast programming language with Rust interoperability
soft-ascii-string
char/str/string wrappers which add a "is-ascii" soft constraint
biscuit-converter
A decimal ASCII parser
gc_abi
Gridcore Plugin Safe ABI Bindings
postgres-parser
An llvm-based safe wrapper for PostgresSQL's query parser. Currently based on v13
vtcode-ghostty-vt-sys
Safe Ghostty VT snapshot wrapper for VT Code
safina-sync
Safe structs for sharing or sending data between async tasks - ARCHIVED: Code moved to
safinacrate
safina-threadpool
Safe thread pool - ARCHIVED: Code moved to
safinacrate
yamp
Minimal Parser - A safe, predictable YAML parser that treats all values as strings
talib
Ta-Lib binding rust safe wrapper
llvm-lib
LLVM library with safe and flexibility in mind, without over complexity based on LLVM-C API
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
safina-net
Safe async network functions - ARCHIVED: Code moved to
safinacrate
fastc-lsp
Language Server Protocol implementation for FastC
xj_ctime
Small library to bridge libc's time API into safe Rust for machine translations
misfortunate
Perverse implementations of safe Rust traits
safe_arith
Safe arithmetic on integers, which avoids overflow and division by zero
wartcl
A minimal embeddable Tcl-like language
safina-async-test
Macro for running async tests - ARCHIVED: Code moved to
safinacrate
dyn_safe
Take control of the Semver hazard of the
dynsafety of your traits!
sharded
Safe, fast, and obvious concurrent collections
cell-gc
A fun garbage collector for that virtual machine you're writing in Rust
stack_frame_allocators
A set of allocators based off the concept of the stack and creating "Frames". Push frames onto the Stack, push values onto Frames, and pop entire Frames and their items
fastc
A safe C-like language that compiles to C11
safina-select
Safe async select function, for awaiting multiple futures - ARCHIVED: Code moved to
safinacrate
lx
A no_std crate to use Linux system calls
ref_kind
Different reference kinds
winix
Unix syscalls on Wine
rustsynth
Safe VapourSynth wrapper
mojo-rs-system
Idiomatic safe Rust System API above the mojo-rs core. Ownership is enforced by Rust types; compatibility lives at the C ABI boundary.
maybe-uninit-ext
Extended maybe-uninit types
flexcell
A flexible cell that allows safe circumvention of double borrow issues
unsize
A stable alternative to CoerceUnsize
zenops-safe-relative-path
Relative path type that statically prevents
..traversal
dicoco_safe_math
simplified safe math operations
craken-container
Compile-time safe dependency injection container for the Craken framework
safecast
Traits to define safe casting between types
zenops-safe-relative-path-validator
Shared traversal-validation logic for
zenops-safe-relative-path
sn_ffi_utils
FFI utilities
net-stress
Loopback network stress for libstress (safe by default)
foreign_vec
Unofficial implementation of Apache Arrow spec in safe Rust
ceph-safe-disk
Ceph disk safety removal tool
lexicon-fs
Safe file operations, diffs, and managed-block patching for lexicon
unit-rs
A safe wrapper around NGINX Unit's libunit
ffi-guy
An attribute macro to automatically make functions FFI safe
moveslot
A trait and newtype enabling safe temporary ownership behind an
&mutreference
safe_unwrap
allows unwrapping and annotating that the unwrap will never fail. Does not require
std.
prudent-macros-lint
prudent-rs internal. Don't use directly/on its own. Instead, see and use prudent.
rustix-libc-wrappers
Safe Rust bindings to
libcfunctions
recursion-visualize
visualized cache-aware stack safe recursion
recursion-schemes
cache-aware stack safe recursion (this is the really haskell brained one)
ps-alloc
a reasonably safe allocator
high_mem_utils
bunch of mem safe abstractions,some involving transmute
gc-sequence
a system for encoding safe points for computations running on gc-arena
secured_linked_list
A cryptographically secured and provable linked list
blkid
Safe blkid-sys wrapper
splay-safe-rs
Splay implemented with safe rust
unsync-pipe
Ringbuffer-backed !Send !Sync binary safe repr(C) AsyncWrite/AsyncRead pair
mapstruct
Create refactor safe derivatives of Structs with proc-macros
ponsic-winsafe
The dependency of the
ponsiccrate
llvm_quick
Rust's wrapper for llvm
backroll
A pure Rust async implementation of GGPO
oncemutex
A mutex providing one-time synchronized access, then safe unsynchronized access
maia
Safe low-level Vulkan bindings
cobhan
FFI is a system for enabling shared code to be written in Rust and consumed from all major languages/platforms in a safe and effective way, using easy helper functions to manage any unsafe data marshaling
pinlist
a safe and easy version of intrusive linked lists
gnu-libjit
A safe rust wrapper around the libjit just in time compiler
rm-improved
rip: a safe and ergonomic alternative to rm
cismute
Safely transmute type to itself in generic contexts
zipwhip-rs
A fast, asynchronous, and safe wrapper around the Zipwhip API
totally-safe
that allows you to bypass Rust's safety guarantees with totally safe patterns, featuring arbitrary lifetimes, aliasing, and more!
uninit_buffers
Safe uninitialized buffers that take input from functions or iterators
siphash_c_d
A no-std, safe, generic implementation of the siphash_c_d algorithm
gls
Open Graphics Library (OpenGL) for Rust bindings with *Safe*, *Simple*, *Speed* and *Stupid*
upgrayedd
Ergonomic function interposition in Rust
totally-speedy-transmute
does safe things with your safe data
safe_uri
safe URI types
static-queue
A statically sized, no_std, allocation-free, safe Rust queue implemented as a ring buffer with full test coverage
ref-portals
Safely use (stack) references outside their original scope
pinned-init-macro
Proc macros for the pinned-init crate
object-safe
Implement object-unsafe traits for trait objects
clamav
bindings for Rust
better-refcell
A drop-in replacement for RefCell with safe unborrow and reborrow capabilities
safe_http
safe HTTP types
async-safe-defer
Minimal async- and sync-capable
defercrate
tink-ffi-sys
Raw FFI bindings to Google Tink via C shim
tablesalt
A safe, oxidized wrapper for libsodium
safe-write
A safe file writing utility
taitank-safe
taitank in safe rust
bitbound
safe, efficient array access with compile time boundary protection
dyn_formatting
limited Python-style safe dynamic (runtime) formatting support for Rust
web30
Async endian safe web3 library
resize_slice2
Resize a slice given a larger slice in safe Rust
webgl-rs
Safe Rust wrapper around the WebGL API
measurement
unit safe computation in rust
projections
Macro-free pin projections because why not?
lemonlang
an experimental, modern, purely safe, programming language
justly
justified containers
gdbm
Safe wrapper for gdbm-sys bindings
rust-salsa20
Fast implementation of salsa20 in safe rust
alloc-safe
Safe memory allocation, no panic!
rolt
Safe(-ish) bindings to Jolt Physics
to_that
Declarative compile safe explict type conversion. Useful for chaining.
hnews
Hacker News API, synchronous and lightweight, thanks to ureq and miniserde!
fast-lru
A fast, 100% safe, stack based LRU cache
friendly_safety_buddy
A fun macro to write safe code with
winpty-rs-windows-services
Windows services
keybinder
Rust wrapper for Keybinder
b64-url
Base 64 Encoding with URL and Filename Safe Alphabet
abox
A safe wrapper around AtomicPtr
fake-enum
creating FFI safe "fake" enum types
cpq
A Concurrent Priority Queue implemented in Safe Rust
nvm_rs
that provides the
nvm!macro to run safe code within unsafe blocks
jajajvm
A safe JVM without any dependency and is so simple, it could put a smile on your face
safe_ecs
ECS written in safe code
safe_uri_ext
Extra URI functionality like parse and display for the safe_uri crate
Try searching with DuckDuckGo.