125 Repositories
Rust skia-safe Libraries
Rustato: A powerful, thread-safe global state management library for Rust applications, offering type-safe, reactive state handling with an easy-to-use macro-based API.
Rustato State Manager A generical thread-safe global state manager for Rust Introduction • Features • Installation • Usage • Advanced Usage • Api Refe
An LSM storage engine designed to significantly reduce I/O amplification written in safe rust (Under active development)
VelarixDB is an LSM-based storage engine designed to significantly reduce IO amplification, resulting in better performance and durability for storage
Prefix tree (ordered map and set) data structure using 100% safe Rust
PFX: A 100% safe, blob-oriented prefix tree This crate provides a prefix tree map and set data structure, implemented purely in safe Rust. The API is
A safe and idiomatic wrapper over shared memory APIs in rust with proper cleanups.
shmem-bind A safe and idiomatic wrapper over shared memory APIs in rust with proper cleanups. Quick start: check the message-passing example for bette
A fast, powerful, and safe interpreter written in rust!
Kraber A fast, powerful, and safe programming language written in rust! About It packs a punch like the Kraber .50-Cal. Kraber is designed to be minim
Thread-safe cell based on atomic pointers to externally stored data
Simple thread-safe cell PtrCell is an atomic cell type that allows safe, concurrent access to shared data. No std, no data races, no nasal demons (UB)
Simple, safe way to store and distribute tensors
Safetensors Ruby 🙂 Simple, safe way to store and distribute tensors Supports Torch.rb and Numo Installation Add this line to your application’s Gemfi
More than safe rust abstractions over rytm-sys, an unofficial SDK for writing software for Analog Rytm running on firmware 1.70.
rytm-rs More than safe rust abstractions over rytm-sys, an unofficial SDK for writing software for Analog Rytm running on firmware 1.70. On top of CC
Hash trait that is object-safe
Hash trait that is object-safe This crate provides a DynHash trait that can be used in trait objects. Types that implement the standard library's std:
Blazing fast, memory safe & modern Linux package manager written in Rust.
paket Blazing fast, memory safe & modern Linux package manager written in Rust. Roadmap Version: 0.1 Paket.toml file parsing. (#1, #2) CLI handling (p
Y-Octo is a high-performance CRDT implementation compatible with yjs
Y-Octo Y-Octo is a high-performance CRDT implementation compatible with yjs. Introduction Y-Octo is a tiny, ultra-fast CRDT collaboration library buil
Zero-cost and safe interface to UEFI firmware
ZFI – Zero-cost and safe interface to UEFI firmware ZFI is a Rust crate for writing a UEFI application with the following goals: Provides base APIs th
The safe, fast and sane package manager for Linux
moss-rs A rewrite of the Serpent OS tooling in Rust, enabling a robust implementation befitting Serpent and Solus We will initially focus on moss and
A safe sync/async multi-producer, multi-consumer channel
Loole A safe async/sync multi-producer multi-consumer channel. Producers can send and consumers can receive messages asynchronously or synchronously:
Rollback-safe implementations and utilities for Bevy Engine
bevy_roll_safe Rollback-safe implementations and utilities for Bevy Engine. Motivation Some of Bevy's features can't be used in a rollback context (wi
A piet frontend for tiny-skia
piet-tiny-skia A piet frontend for the tiny-skia framework. tiny-skia is a very high-quality implementation of software rendering, based on the algori
nvim-oxi provides safe and idiomatic Rust bindings to the rich API exposed by the Neovim text editor.
🔗 nvim-oxi nvim-oxi provides safe and idiomatic Rust bindings to the rich API exposed by the Neovim text editor. The project is mostly intended for p
A generational arena based LRU Cache implementation in 100% safe rust.
generational-lru Crate providing a 100% safe, generational arena based LRU cache implementation. use generational_lru::lrucache::{LRUCache, CacheError
A type-safe, K-sortable, globally unique identifier
type-safe-id A type-safe, K-sortable, globally unique identifier. Typed implementation of https://github.com/jetpack-io/typeid in Rust. Examples Stati
Safe, fully-featured bindings to the Tracy profiler
Complete Rust bindings for the Tracy profiler. Getting Started Just add the following to your Cargo.toml: [dependencies.tracy] package = "tracy_full"
Alternative future adapters that provide cancel safety.
cancel-safe-futures Alternative futures adapters that are more cancel-safe. What is this crate? The futures library contains many adapters that make w
A comprehensive collection of resources and learning materials for Rust programming, empowering developers to explore and master the modern, safe, and blazingly fast language.
🦀 Awesome Rust Lang ⛰️ Project Description : Welcome to the Awesome Rust Lang repository! This is a comprehensive collection of resources for Rust, a
Lightweight async Redis client with connection pooling written in pure Rust and 100% memory safe
redi-rs (or redirs) redi-rs is a Lightweight Redis client with connection pooling written in Rust and 100% memory safe redi-rs is a Redis client writt
Unsafe bindings and a safe wrapper for gtk4-layer-shell, automatically generated from a .gir file
gtk4-layer-shell: gtk4-layer-shell-sys: gtk4-layer-shell This is the safe wrapper for gtk4-layer-shell, automatically generated from its .gir file. Fo
Type safe multipart/form-data handling for axum.
axum_typed_multipart Designed to seamlessly integrate with Axum, this crate simplifies the process of handling multipart/form-data requests in your we
A type-safe Rust interface to the Nix CLI
runix A typesafe interface to the nix CLI. by flox Installation Install with cargo add (Rust = 1.64) cargo add runix Alternatively, manually add runi
Linked Atomic Random Insert Vector: a thread-safe, self-memory-managed vector with no guaranteed sequential insert.
Linked Atomic Random Insert Vector Lariv is a thread-safe, self-memory-managed vector with no guaranteed sequential insert. It internally uses a linke
Thread-safe clone-on-write container for fast concurrent writing and reading.
sync_cow Thread-safe clone-on-write container for fast concurrent writing and reading. SyncCow is a container for concurrent writing and reading of da
A safe, fast and cross-platform 2D component-based game framework written in rust
shura shura is a safe, fast and cross-platform 2D component-based game framework written in rust. shura helps you to manage big games with a component
A library for writing type-safe Durable Objects in Rust.
do-proxy A library for writing type-safe Durable Objects (DOs) in Rust. With do-proxy you can: Easily write type-safe APIs for Durable Objects. Abstra
A blazingly fast and memory safe password cracker with user interface.
HashVat A blazingly fast and memory safe password cracker with user interface. HashVat runs with user interface and is capable of cracking the 1.000.0
🗄️ A simple (and safe!) to consume history of Client and Studio deployment versions.
🗄️ Roblox Version Archive A simple (and safe!) to consume history of Client and Studio deployment versions. About Parsing Roblox's DeployHistory form
A additional Rust compiler pass to detect memory safe bugs of Rust programs.
SafeDrop A additional Rust compiler pass to detect memory safe bugs of Rust programs. SafeDrop performs path-sensitive and field-sensitive inter-proce
Gnosis Safe Tx Service API client & associated tooling
Safe Transaction Service API Client Using the SDK Instantiate an API client use safe_sdk::SafeClient; /// From a chain id, by looking up hardcoded en
Safe API to embed an ECMAScript engine.
Kopi Kopi is a small abstraction to easily and safely embed an ECMAScript runtime inside a Rust based application. It uses the V8 execution engine to
Simple, safe way to store and distribute tensors
safetensors Safetensors This repository implements a new simple format for storing tensors safely (as opposed to pickle) and that is still fast (zero-
A safe, fast, lightweight embeddable scripting language written in Rust.
Bud (budlang) A safe, fast, lightweight embeddable scripting language written in Rust. WARNING: This crate is not anywhere near being ready to publish
Safe Unix shell-like parameter expansion/variable substitution via cross-platform CLI or Rust API
Safe Unix shell-like parameter expansion/variable substitution for those who need a more powerful alternative to envsubst but don't want to resort to
Safe MMDeploy Rust wrapper.
Introduction Safe MMDeploy Rust wrapper. News (2022.9.29) This repo has been added into the OpenMMLab ecosystem. (2022.9.27) This repo has been added
Safe, idiomatic bindings to cFE and OSAL APIs for Rust
n2o4 The n2o4 crate provides safe, idiomatic Rust bindings to the APIs of cFE and OSAL, the libraries of the Core Flight System (cFS). IMPORTANT NOTE
Render egui with skia!
Skia backend for egui This is a drawing backend for egui that uses skia-safe. Usage Have a look at the metal or cpu examples to get started. Run the e
Simple, thread-safe, counter based progress logging
🦫 proglog Documentation Crates.io This is a simple, thread-safe, count-based, progress logger. Synopsis proglog hooks into your existing log implemen
A safe wrapper around Gamercade's raw Api.
gamercade-rs A safe wrapper around Gamercade's Raw Api. As the Raw Api requires using a lot of unsafe and hiding of values through different types (fo
A type-safe, high speed programming language for scalable systems
A type-safe, high speed programming language for scalable systems! (featuring a cheesy logo!) note: the compiler is unfinished and probably buggy. if
A safe `Pin`-based intrusive doubly-linked list in Rust
pin-list This crate provides PinList, a safe Pin-based intrusive doubly linked list. Example A thread-safe unfair async mutex. use pin_project_lite::p
Simple type-safe relational algebra evaluator built entirely in Rust
ra-evaluator A simple type-safe relational algebra evaluator. Relational algebra provides the theoretical foundation for relational databases and the
Safe rust abstractions over libpd.
libpd-rs Safe rust abstractions over libpd-sys. Pure Data (Pd) is a visual programming language developed by Miller Puckette in the 1990s for creating
Amethyst is a systems language aimed at being simple, small, portable, and safe.
amethyst Amethyst is a systems language aimed at being simple, small, portable, and safe. What is this language? From the r/ProgLangs discord server:
Usable, easy and safe pure-Rust crypto
orion About Orion is a cryptography library written in pure Rust. It aims to provide easy and usable crypto while trying to minimize the use of unsafe
Build database expression type checker and vectorized runtime executor in type-safe Rust
Typed Type Exercise in Rust Build database expression type checker and vectorized runtime executor in type-safe Rust. This project is highly inspired
Type-safe IPC for Tauri using GraphQL
Tauri Plugin graphql A plugin for Tauri that enables type-safe IPC through GraphQL. Install Rust [dependencies] tauri-plugin-graphql = "0.2" JavaScrip
A simple, stable and thread-safe implementation of a lazy value
Laizy Laizy is a Rust library that provides a simple, stable and thread-safe implementation of a Lazy Features Name Description Dependencies nightly A
Type-safe SQL query wrappers
fnsql The fnsql crate provides simple type-safe optional wrappers around SQL queries. Instead of calling type-less .query() and .execute(), you call
An abstract, safe, and concise color conversion library for rust nightly This requires the feature adt_const_params
colortypes A type safe color conversion library This crate provides many methods for converting between color types. Everything is implemented abstrac
🔌 A curseforge proxy server, keeping your API key safe and sound.
🔌 CFPROXY - The curseforge proxy server Curseforge has locked down their API and now restricts access without authentification. This spells trouble f
Safe OCaml-Rust Foreign Function Interface
ocaml-rust This repo contains code for a proof of concept for a safe OCaml-Rust interop inspired by cxx. This is mostly optimized for calling Rust cod
A set of safe Least Recently Used (LRU) map/cache types for Rust
LruMap A set of safe Least-Recently-Used (LRU) cache types aimed at providing flexible map-like structures that automatically evict the least recently
NixEl is a Rust library that turns Nix code into a variety of correct, typed, memory-safe data-structures
🐉 NixEL Lexer, Parser, Abstract Syntax Tree and Concrete Syntax Tree for the Nix Expressions Language. NixEl is a Rust library that turns Nix code in
Next-generation, type-safe CLI parser for Rust
Next-generation, type-safe CLI parser for Rust
A collection of unsound rust functions using entirly *safe* code
A collection of unsound rust functions using entirly *safe* code
Tool for computing vanity Gnosis Safe addresses
0xdeadbeef Tool used for computing vanity Gnosis Safe addresses. This tool is currently hard-coded to only support the v1.3.0 Safe deployment: GnosisS
Define safe interfaces to MMIO and CPU registers with ease
regi regi lets you define safe interfaces to MMIO and CPU registers with ease. License Licensed under either of Apache License, Version 2.0 or MIT lic
ODBC wrapper for safe idiomatic Rust
ODBC wrapper for safe idiomatic Rust Library for writing ODBC applications in Rust. If you're looking for raw ODBC FFI bindings check odbc-safe and od
Safe Rust bindings to the DynamoRIO dynamic binary instrumentation framework.
Introduction The dynamorio-rs crate provides safe Rust bindings to the DynamoRIO dynamic binary instrumentation framework, essentially allowing you to
Safe, efficient, and ergonomic bindings to Wolfram LibraryLink and the Wolfram Language
wolfram-library-link Bindings to the Wolfram LibraryLink interface, making it possible to call Rust code from the Wolfram Language. This library is us
A safe Rust wrapper around a subset of cuFFT.
cufft_rust This is a safe Rust wrapper around CUDA FFT (cuFFT). It only supports a subset of the API which I need for private projects. For now this o
untyped-arena provides an Arena allocator implementation that is safe and untyped with minimal complexity
untyped-arena untyped-arena provides an Arena allocator implementation that is safe and untyped with minimal complexity Usage let arena = Arena::new()
Inkwell - It's a New Kind of Wrapper for Exposing LLVM (Safely)
Inkwell(s) It's a New Kind of Wrapper for Exposing LLVM (Safely) Inkwell aims to help you pen your own programming languages by safely wrapping llvm-s
Neovide - No Nonsense Neovim Client in Rust
Neovide This is a simple graphical user interface for Neovim (an aggressively refactored and updated Vim editor). Where possible there are some graphi
Diesel - A safe, extensible ORM and Query Builder for Rust
A safe, extensible ORM and Query Builder for Rust API Documentation: latest release – master branch Homepage Diesel gets rid of the boilerplate for da
a Rust library implementing safe, lightweight context switches, without relying on kernel services
libfringe libfringe is a library implementing safe, lightweight context switches, without relying on kernel services. It can be used in hosted environ
A blazing fast, type-safe template engine for Rust.
markup.rs A blazing fast, type-safe template engine for Rust. markup.rs is a template engine for Rust powered by procedural macros which parses the te
Thin but safe ALSA wrappers for Rust
ALSA bindings for Rust Thin but safe wrappers for ALSA, the most common API for accessing audio devices on Linux. The ALSA API is rather big, so every
A fast Rust-based safe and thead-friendly grammar-based fuzz generator
Intro fzero is a grammar-based fuzzer that generates a Rust application inspired by the paper "Building Fast Fuzzers" by Rahul Gopinath and Andreas Ze
Safe Rust crate for creating socket servers and clients with ease.
bitsock Safe Rust crate for creating socket servers and clients with ease. Description This crate can be used for Client -- Server applications of e
A type-safe, high performance ORM framework
A type-safe, high performance ORM framework
rt-history: An RT-safe history log with error checking
rt-history: An RT-safe history log with error checking This is a bounded wait-free thread synchronization primitive which allows you to record the tim
The Safe Network Core. API message definitions, routing and nodes, client core api.
safe_network The Safe Network Core. API message definitions, routing and nodes, client core api. License This Safe Network repository is licensed unde
A safe-against-invalid-input version of wren.io, written in Rust.
safe_wren A nearly-complete implementation of the Wren language (wren.io) in Rust. The original https://github.com/wren-lang/wren from wren.io is refe
The working code for my Safe Pay app - check out my tutorial!
Safe Pay Tutorial This repository contains the source code for my blog post Using PDAs and SPL Token in Anchor. The code contains the following: Solan
✨ Safe, global singletons initialized at program start
✨ magic_static Safe, global singletons initialized at program start. Usage Simply add magic_static as a dependency in your Cargo.toml to get started:
Safe Rust interface to the Vulkan API.
Magma: A strictly typed Vulkan API interface. Magma is a strictly typed Rust interface for the vulkan API. This means that whenever possible, the well
A cross-platform and safe Rust API to create and manage memory mappings in the virtual address space of the calling process.
mmap-rs A cross-platform and safe Rust API to create and manage memory mappings in the virtual address space of the calling process. This crate can be
Fast, initializable, and thread safe static variables
tagged_cell Fast, initializable, and thread safe static variables Overview Borrows the excellent ZST based tagging implementation (linked below) to gu
High-level memory-safe binding generator for Flutter/Dart - Rust
flutter_rust_bridge: High-level memory-safe binding generator for Flutter/Dart - Rust Want to combine the best between Flutter, a cross-platform hot
Safe, comp time generated queries in rust
query_builder For each struct field following methods will be generated. All fields where_FIELDNAME_eq Numeric fields where_FIELDNAME_le where_FIELDNA
Garbage Collector(Hyaline- Safe Memory Reclaimation) for lock free data structures
Hyaline-SMR This crate provides garbage collection using hyaline algorithm for building concurrent data structures. When a thread removes an object fr
Display strings in a safe platform-appropriate way
os_display Printing strings can be tricky. They may contain control codes that mess up the message or the whole terminal. On Unix even filenames can c
This crate allows you to safely initialize Dynamically Sized Types (DST) using only safe Rust.
This crate allows you to safely initialize Dynamically Sized Types (DST) using only safe Rust.
Generator of Firestore rules and type safe client code.
Generator of Firestore rules and type safe client code. Usage [WIP] Install from npm or curl. $ npm install -g firegen Setting your yml. # firegen.yml
Rust library for developing safe canisters.
IC Kit This library provides an alternative to ic-cdk that can help developers write canisters and unit test them in their Rust code. Install Add this
🚀Memory safe, blazing fast, configurable, minimal hello world written in rust(🚀) in a few lines of code with few(1092🚀) dependencies🚀
🚀 hello-world.rs 🚀 🚀 Memory safe, blazing fast, minimal and configurable hello world project written in the rust( 🚀 ) programming language 🚀 🚀 W
A memory safe Lua interpreter
Hematita Da Lua Hematita Da Lua is an interpreter for the scripting language Lua, written entirely in 100% safe Rust. Hematita is the portugese word f
A thread-safe signal/slot library based on boost::signals2
About signals2 is a thread-safe signal/slot library based on the boost::signals2 C++ library. Signals are objects that contain a list of callback func
A fast Rust-based safe and thead-friendly grammar-based fuzz generator
Intro fzero is a grammar-based fuzzer that generates a Rust application inspired by the paper "Building Fast Fuzzers" by Rahul Gopinath and Andreas Ze
A safe implementation of the secure remote password authentication and key-exchange protocol (SRP), SRP6a and legacy are as features available.
Secure Remote Password (SRP 6 / 6a) A safe implementation of the secure remote password authentication and key-exchange protocol (SRP version 6a). Ver
Volt - A powerful, fast and memory safe package manager for the web
Volt - A powerful, fast and memory safe package manager for the web
Totally Speedy Transmute (TST) is a library providing a small, performance oriented, safe version of std::mem::transmute
Totally Speedy Transmute An evil spiritual successor to Totally Safe Transmute What is it? Totally Speedy Transmute (TST) is a library providing a sma
Rust ABI safe code generator
CGlue offers an easy way to ABI (application binary interface) safety. Just a few annotations and your trait is ready to go!
Thread Safe Cache with async loader functions based on tokio-rs
cache-loader-async crates.io The goal of this crate is to provide a thread-safe and easy way to access any data structure which might is stored in a d