Lib.rs

ouroboros

Easy, safe self-referential struct generation

uninit

A collection of tools for a safer usage of uninitialized memory

va_list

'va_list' type for a small set of ABIs. Allowing rust implementations of functions like vprintf.

tinyrlibc

Tiny, incomplete C library for bare-metal targets, written in Stable (but Unsafe) Rust

maybe-dangling

ManuallyDrop<T> and MaybeDangling<T> semantics in stable Rust as per https://github.com/rust-lang/rfcs/pull/3336

esaxx-rs

Wrapping around sentencepiece's esaxxx library

columnation

Unsafe columnar containers for native Rust types

geiger

Some library parts of cargo-geiger, decoupled from cargo

grounded

A toolkit for managing unsafe statics

hyper_byte

An unsafe, near-zero cost (1-2 instructions) byte transmuter to numeric types with fast byte reader, writer, and read-writer

craturn

interpretation of the 'Saturn Devouring His Son' painting

safe-manually-drop

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

drop-with-owned-fields

Safe and sound owned access to a struct’s fields in Drop: no more unsafe usage of ManuallyDrop!

prudent

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

corroded-rs

that bypasses Rust's safety features

linux-unsafe

Raw linux system call stubs

phylactery

Safe and thin wrappers around lifetime extension to allow non-static values to cross static boundaries

debug_unsafe

Uses debug-assertions as a switch of safe/unsafe behaviour

count-unsafe

Recursively count unsafe Rust code in a given path

unsafe-tools-mimic

Size and alignment matched opaque types

unsafe-libopus

libopus transpiled to rust by c2rust

unsafe_cell_slice

A microlibrary for creating multiple mutable references to a slice

stackaroo

Swap out of the OS-provided stack

unwind_safe

Readable unwind-safe code thanks to a try-finally-looking builder pattern

cargo-geiger

Detects usage of unsafe Rust in a Rust crate and its dependencies

modu_ffi

FFI library for modu

raw-parts

Ergonomic wrapper around Vec::from_raw_parts and Vec::into_raw_parts

unsafe-tools

A collection of tools making safer unsafe Rust

revel_cell

owa4x

Idiomatic wrapper around the owa4x-sys crate

manually-static

ManualStatic that is a wrapper which allows to manually manage 'static lifetimes. It is unsafe but with debug_assertions it panics when the usage is wrong

unsafe-budget

keeps the unsafety demons out. an unsafe code budget gate for CI pipelines.

borrowck_sacrifices

Necessary sacrifices to keep the Borrow Checker happy and developers sane

merc_unsafety

Internal MERC toolset package containing various utility functions that use unsafe code blocks

praborrow-logistics

Zero-copy buffer abstraction. Handles raw byte streams without allocation overhead.

unsafe-tools-canary

Runtime initialization checking for Rust types

safety-parser

A lib for parsing safety tags defined in tag-std

fftw-sys

unsafe wrapper of FFTW3

safe-gc

A garbage collection library with zero unsafe code and zero dependencies

kasane-logic

This is Kasane-logic

light_ranged_integers

Ranged integers for stable Rust compiler, zero-dependencies and no unsafe code

mem_btree

A Data Structure of BTree Implemented with Rust, support snapshot. not use any unsafe lib.

expand_any_lifetime

expand any lifetime to 'static with no unsafe rust

abomonation

A high performance and very unsafe serialization library

siderophile

Find the ideal fuzz targets in a Rust codebase

unsafe_list

基于 linux 的 list 实现

olis_string

Small-string optimization for Rust, aims to replace std::string::String

unsafe-fields

unsafe to access or modify fields with safety invariants

android-mem-kit

A comprehensive memory instrumentation library for Android rooted environments (Il2Cpp, Hooking, Patching)

lv-std

some utils for c and unsafe rust, this is for personal use for now so you can use it but don't expect any regular updates or maintaining

trustmebro-macro

A macro that wraps arbitrary tokens in an unsafe block

cargo-geiger-serde

TODO: Write description

kroos

Flexible smart pointer for ?Sized types with customizable reference counting

gtk4-layer-shell-sys

Unsafe gir-generated FFI bindings for gtk4-layer-shell

make-send-sync

Unsafely make any type Send and Sync

unsafe-send-sync

Unsafe wrappers for making structs Send and/or Sync

uninit-helper

Utilites to encapsulate some unsafety of MaybeUninit

stuff

Stuffing things into pointers

skiplist-rust

A lockless skiplist implementation in Rust

pre

Compile-time assistance for working with unsafe code

maybe-uninit-ext

Extended maybe-uninit types

rustls-lite

Experimental unsafe non-affiliated rustls lite fork. Don't use please.

nvm_rs

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

phidget-sys

Low-level, unsafe, Rust wrapper for the phidget22 library

generic-str

Annoyed that Rust has two string types? Well it doesn't any more

unsafe-any

Traits and implementations for unchecked downcasting

better_unsafe

Unsafe utilities

taskwarrior-sys

Rust bindings for taskwarrior

slog2-parse

that wraps methods defined in libslog2parse in an idomatic rust interface. Also exposes all unsafe c ffi functions via a ffi module.

drm-rs

(WIP) libdrm bindings to be able to use Kernel Mode Setting on Linux

slog2

that wraps methods defined in libslog2 in an idomatic rust interface. Also exposes all unsafe c ffi functions via a ffi module.

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

cargo-whynot

Cargo subcommand to discover why a function is unsafe

unsafe-any-ors

Traits and implementations for unchecked downcasting

proton-sdk-sys

An unsafe rust binding for the Proton Apps SDK. Currently a WIP

machinecode

Execute machine code in hex form

ipopt-sys

Raw unsafe Rust bindings to the Ipopt non-linear optimization library

slog2-extra

that wraps methods defined in libslog2-extra in an idomatic rust interface. Also exposes all unsafe c ffi functions via a ffi module.

rust_hero

Rust assistant that utilizes NLP to enhance the quality of rust code

unsafe_unwrap

Unsafely unwrap Result and Option types without checking

unchecked-std

some methods from the Rust standard library without some checks

unsafe-io

has been renamed to io-extras

unsafe_math

proc_macro to replace math operation with their unchecked/f_fast versions

abort_on_panic

Intercept panic! from unsafe locations and abort the process

reference-box

Allows developers to pass non-owned references to Rust-allocated structures over ffi

kubectl-check

A CLI tool to prompt users for confirmation before running potentially unsafe kubectl commands

gtk4-session-lock-sys

Unsafe gir-generated FFI bindings for gtk4-session-lock

rusty_malloc

A multithreaded yet simple memory allocator written in Rust

unchecked_wrap

Convenient UncheckedSync/Send wrapper types

ffizz

exporting Rust libs for use in other languages

project-uninit

Macros for safe references to and initialization of fields in MaybeUninit structs

umath

ffast-math in rust

bointer

Assorted pointer-related utilities

unsafe_bst

bst crate, created as a project for class

unsafe-to-verified

Renames unsafe to verified (kinda)

accounts-service-sys

Unsafe gir-generated FFI bindings for accountsservice

fricgan

performing basic input and output on bytes

super_cell

A super (unsafe) cell that also implements send and sync regardless of the inner type's send/sync

uncon

Traits for unchecked conversions between types

safevalue

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

hubs

The horribly unsafe buffer structure

sealingslice

A mutable slice that can seal its initial part off from mutability, and hand out the sealed parts as immutable references

mumblelink_reader

Mumblelink reader for Windows & Unix based operating systems

unsafe_ls

list unsafe blocks and the unsafe actions within them, to enable easier auditing of regions that need extra-careful examination

guerrilla

(or Monkey) Patching in Rust for (unsafe) fun and profit

genz

Uniqueness of types via invariant lifetimes

shut_up

Use trust_me、shut_up or other keywords replace 'unsafe'. Compiler shut up! Readers shut up too! My code has no bugs, trust me!

trustmebro

macro that magically turns unsafe code into ‘totally safe, bro’ with no consequences. Ideal for those who want to assert dominance over the compiler and live on the edge of catastrophe.

memdump

Handy unsafe no_std memory dumper utility library written in Rust

sendify

An unsafe crate to wrap a reference to make it Send + Sync

noise_perlin

Improved perlin noise in 2D and 3D

trust_me

Just replace unsafe keyword to safe! macro. Always trust programmers.

trustme

Tell the compiler that you can be trusted to write unsafe code!

into_inner_drop

A helper library for implementing into_inner method for drop types safely

safe

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

vec_ptr

An unsafe vector that uses raw pointers to perform standard vector operations

localize

Localization library

uninitialized

Opt-in unsafe uninitialized memory

sussy

pierwszy kwietnia

uncooked_slices

A wrapper around raw slice pointers that enables safe iteration and indexing

unsafe-ref

Allow raw pointer access without those pesky unsafe blocks everywhere!

sus

A declarative macro that wraps any input with an unsafe block

urc

unsafe shared ptr

reduce_unsafe

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

promise-unsafe

Something help you avoid unsafe:)

safety-guard

#[safety] attribute to generate a corresponding doc entry and a debug assertion if a constraint is specified

safe_attr

An attribute #[safe] to mark functions, allowing the ommission of unsafe

pointer

easier to iterate on pointers

clonable_trait_object

clonar objectos traits sin usar unsafe

nsf-imgui-raw

Alternative (personal) imgui rust bindings, unsafe ffi part

haque

An abomination for messing with memory

unsafer

Convenience library for Unsafe Rust

unsafe_from

Unsafe versions of standard library From<T> and Into<T>

safety-macro

A macro for using safety tags defined in tag-std