Lib.rs

rustc_version

A library for querying the version of a installed rustc compiler

vergen

Generate ‘cargo:rustc-env’ instructions via ‘build.rs’ for use in your code via the env! macro

kube

Kubernetes client and futures controller runtime

pretty_assertions

Overwrite assert_eq! and assert_ne! with drop-in replacements, adding colorful diffs

embed-resource

A Cargo library to handle compilation and inclusion of Windows resources in the most resilient fashion imaginable

platforms

Rust platform registry with information about valid Rust platforms (target triple, target_arch, target_os) sourced from Rust Forge

assert-json-diff

Easily compare two JSON values and get great output

wiremock

HTTP mocking to test Rust applications

include_dir

Embed the contents of a directory in your binary

duct

a library for running child processes

orbtk

The Orbital Widget Toolkit

self_update

Self updates for standalone executables

version-sync

Crate for ensuring that version numbers in README files and other files are kept in sync with the crate version

xargo

The sysroot manager that lets you build and customize std

crates-index

Library for retrieving and interacting with the crates.io index

fnm

Fast and simple Node.js version manager

k8s-openapi

Bindings for the Kubernetes client API

determinator

Figure out which packages changed between two commits to a workspace

cargo-udeps

Find unused dependencies in Cargo.toml

cargo-binutils

Proxy for LLVM tools like llvm-nm, llvm-objdump and llvm-size

version_check

Tiny crate to check the version of the installed/running rustc

tinyfiledialogs

High-level Rust binding for the tinyfiledialogs C library

rustsec

Client library for the RustSec security advisory database

enclose

A convenient macro for cloning values into a closure

cargo-husky

husky for cargo

rusty-hook

git hook utility

diesel_cli_ext

Provides different tools for projects using the diesel_cli

rune

An embeddable dynamic programming language for Rust

rls-span

Types for identifying code spans/ranges

libgit2-sys

Native bindings to the libgit2 library

barcoders

A barcode-encoding library

hakari

Manage workspace-hack packages that do feature unification inside workspaces

ruwren

Rusty bindings to Wren programming language

cage

Develop multi-pod docker-compose apps

rmodbus

Fast and platform-independent Modbus server framework

sqlformat

Formats whitespace in a SQL string to make it easier to read

uniffi_bindgen

a multi-language bindings generator for rust (codegen and cli tooling)

indy

A library for assisting developers using LibIndy API

dprint

Binary for dprint code formatter—a pluggable and configurable code formatting platform

paperclip

OpenAPI tooling library for type-safe compile-time checked HTTP APIs

const-random

Provides compile time random number generation

crunchy

Crunchy unroller: deterministically unroll constant loops

bcc-sys

Rust binding to BPF Compiler Collection (BCC)

minitt

Mini-TT, a dependently-typed lambda calculus, extended and (re)implemented in Rust

python3-sys

FFI Declarations for Python 3

crates-index-diff

Learn what’s changed in the crates.io index

duckscriptsdk

The duckscript SDK

duckscript

Simple, extendable and embeddable scripting language

rustfmt-nightly

Tool to find and fix Rust formatting issues

source-span

Source code mapping and display utilities

rustup-toolchain-install-master

Install master rustc toolchain into rustup

rune-cli

An interpreter for Rune, an embeddable dynamic programming language for Rust

man

Generate structured man pages

digitalocean

A pure Rust DigitalOcean API binding

tracing-gelf

A Graylog tracing library

python27-sys

FFI Declarations for Python 2.7

path-dsl

A utility DSL and macro to help deal with Paths and PathBufs

toast

Containerize your development and continuous integration environments

svls

SystemVerilog language server

suspicious-pods

Prints a list of k8s pods that might not be working correctly

koto_runtime

The runtime used by the Koto programming language

wingman

Static site generator and theming engine

opaque_typedef

Supports defining opaque typedefs

git-workspace

Manage and update personal and work git repos from multiple providers

voile

Voile, a dependently-typed row-polymorphic programming language

vhdl_lang

VHDL Language Frontend

duplicate

The attribute macro duplicate can duplicate an item with variable substitution

cargo-rls-install

Rust Language Server easy install

rojo

Enables professional-grade development tools for Roblox developers

alfred

A library for writing Alfred workflows. http://www.alfredapp.com

febug

anyway, here’s user-space debugfs

llama

Friendly LLVM bindings

const-random-macro

Provides the procedural macro used by const-random

cfg-expr

A parser and evaluator for Rust cfg() expressions

koto_parser

The parser used by the Koto programming language

grpc-build

gPRC compilation made easy

fuzzcheck_traits

Definition of traits used by fuzzcheck-rs

newrelic

Idiomatic Rust bindings to the New Relic C SDK. Note: versions 0.1.0 onwards of this crate are completely incompatible with previous versions as they move away from the deprecated New Relic SDK…

delay_timer

Time-manager of delayed tasks. Like crontab, but synchronous asynchronous tasks are possible, and dynamic add/cancel/remove is supported.

abci

Tendermint ABCI server for Rust

cargo-no-std-check

Check that a crate builds without std

xgadget

Fast, parallel, cross-variant ROP/JOP gadget search for x86/x64 binaries

makers

a POSIX-compatible make implemented in Rust

geiger

Some library parts of cargo-geiger, decoupled from cargo

cl-traits

Provides traits that describe collections

jokeyrhyme-dotfiles

read my dotfiles repository and do stuff

click

A command-line REPL for Kubernetes that integrates into existing cli workflows

psl-codegen

Generate native Rust code from Mozilla’s Public Suffix List

rogcat

A adb logcat wrapper and log processor

git-gone

Manage “gone” Git branches

protospec

One binary format language to rule them all, One binary format language to find them, One binary format language to bring them all and in the darkness bind them

protobuf-convert

Macros for convenient serialization of Rust data structures into/from Protocol Buffers

rebuilderd

rebuilderd - independent build verification daemon

easylog

A simple and easy to use logging-crate. Write log-messages to a file.

constellation-rs

Constellation is a framework for Rust (nightly) that aides in the writing, debugging and deployment of distributed programs

koto_bytecode

The bytecode compiler used by the Koto programming language

gluon_codegen

Code generation macros for the gluon programming language

committed

Nitpicking commit history since beabf39

rustfilt

Demangle Rust symbol names

rerun_except

Rerun a cargo build except when specified files are changed

rustc_version_runtime

A library for querying the version of the rustc compiler used in runtime

magicpak

Build minimal docker images without static linking

papyrus

A rust repl and script runner

snare

GitHub webhooks runner daemon

rune-modules

Native modules for Rune, an embeddable dynamic programming language for Rust

stb_truetype

A straight translation of the font loading code in stb_truetype.h from C to Rust

selene-lib

A library for linting Lua code. You probably want selene instead.

blisp-repl

REPL of BLisp, a lisp like statically typed programing language for no_std

compose_yml

Parse, manipulate and serialize docker-compose.yml in a strongly-typed fashion

fluminurs

A client in Rust to access the reverse-engineered LumiNUS API

swc_ecma_codegen

Ecmascript code generator for the swc project

janetrs

High level binding for Janet programming language

tough

The Update Framework (TUF) repository client

avatar-cli

Magic wrapper to run containerized CLI tools

rustc_tools_util

small helper to generate version information for git packages

corundum

Persistent Programming Library

dymod

A macro to allow hotswapping code for a module in debug mode, but statically linking it safely in release mode

quickjs_runtime

An API and Utils around the QuickJS script engine

binary-security-check

Analyzer of security features in executable binaries

dfw

Docker firewall framework, in Rust

codegenrs

Moving code-gen our of build.rs

polonius-engine

Core definition for the Rust borrow checker

constellation-internal

Common components for the constellation framework

cluConstData

Create and merge any persistent data at compile time

penguin-app

Dev server with auto-reload, static file server, proxy support, and more. Language and framework agnostic. This is the CLI app, but Penguin exists as a library, too.

rustler_codegen

Compiler plugin for Rustler

toodoux

A modern task management tool

cranelift-codegen-meta

Metaprogram for cranelift-codegen code generator library

crndm_derive

Persistent Programming Library Procedural Macros

chalk-engine

Core trait engine from Chalk project

autozimu/languageclient

Language Server Protocol (LSP) support for vim and neovim

onepassword-cli

a wrapper for 1password-cli, which focus on easy-to-use

venv-wrapper

Simple python virtual environment management

bruh

Homebruh is package manager for GNU/Linux

rustygit

A simple interface for runnig Git commands

llvmenv

Manage LLVM/Clang builds

difflib

Port of Python’s difflib library to Rust

eclectica

Cool and eclectic version manager for any language

develop_debug

Print debugging information at development time

blindfold

⚙️ gitignore file generator written in rust

core-nightly

Nightly build of libcore from the rust repo

little-skeptic

Test your Rust markdown documentation via Cargo

rtlola-frontend

A frontend for the RTLola runtime verification framework

repotools

Short names, big time savings. Repotools is a collection of commands with short but meaningful names, for the git operations you perform most often.

penguin

Dev server with auto-reload, static file server, proxy support, and more. Language and framework agnostic. This is the library crate, but Penguin exists as a CLI app, too.

crev-wot

Scalable, social, Code REView system that we desperately need - Web of Trust library

rls-analysis

Library for processing rustc’s save-analysis data for the RLS

c2rust-transpile

C2Rust transpiler implementation

libhandy

Rust bindings for libhandy

chalk-recursive

Recursive solver for the Chalk project

moz-cheddar

A library to automatically generate C header files from Rust source files

starlark-repl

A REPL for the implementation in Rust of the Starlark language

uniffi

a multi-language bindings generator for rust (runtime support code)

es_runtime

An API and Utils around the spidermonkey script engine

httpserv

A tiny, zero-dependency fileserver for local HTML development

devx-pre-commit

Utilities for creating git pre-commit hooks useful in rust projects

ift-webhook

a convenient tool for trigger ifttt’s webhooks

endbasic-core

The EndBASIC programming language - core

depub

Reduce function/struct visibility

features

A macro to generate runtime feature toggles

fix-getters-def

Fix getters definition by removing the get prefix when applicable

polyerror

Macro to make errors easy and expressive

llvm-alt

A wrapper for LLVM, a powerful library and toolkit for compilers

srws

srws (Simple rust web server) is a simple HTTP only web server

epine

A Makefile generator for the 21st century

prost-helper

A set of prost helper functions to make prost generated code easy to work with

py_mcai_worker_sdk

AMQP Worker to listen and provide trait to process message

gitlab-butler-lib

Support library for gitlab-butler Gitlab cli to automate the boring stuff

ptags

A parallel universal-ctags wrapper for git repository

shkeleton

Skeleton rust project

cargo-bisect-rustc

Bisects rustc toolchains with rustup

opentelemetry-http

Helper implementations for exchange of traces and metrics over HTTP

rustdoc-index

A fast listing tool for rustdoc

koto_lexer

The lexer used by the Koto programming language

fix-getters-calls

Fix getters call sites by removing the get prefix when applicable

saltwater

A C compiler written in Rust, with a focus on good error messages

flapigen

Tool for connecting libraries written in Rust with other languages

gluon_doc

The documentation generator for the gluon programming language

libcec-sys

FFI bindings to libcec

endbasic

The EndBASIC programming language - CLI

xdrgen

XDR codec generator from specification. Designed for use with xdr-codec.

background-jobs-actix

in-process jobs processor based on Actix

mangling

mangling generates safe, recognizable identifiers from byte streams

fp-core

A library for functional programming in Rust

delog

Deferred logging, an implementation and extension of Rust’s standard logging facade

devbox

Developer toolbox for building and testing

duplicate_code

A tool for parsing directories scanning all the files within to find duplicate segments of code across files

catflap

Creates a TCP socket and passes its descriptor as an env variable

project-cleanup

CLI tool to clean up and remove old generated code in your Rust, Javascript and Java projects

binks

The binks scripting language

crev-lib

Scalable, social, Code REView system that we desperately need - core library

metacrate

Metadata for crates

changelog

Changelog generator

verboten

A service wrapper to start msvsmon in a hazardous mode

fuzzcheck

A coverage-guided, structure-aware fuzzing engine for Rust functions

took

Easily measure & report elapsed time

cache-buster

cache-buster helps static sites keep assets cached gracefully

parsec-client

Parsec Client library for the Rust ecosystem

llvm-passgen

A tool for quickly creating LLVM pass skeletons

rust-dropbox

a convenient tool of dropbox-api binding, with non-blocking and blocking api

ptx-linker

NVPTX modules linker

shaku_rocket

Integration between shaku and Rocket

reusable-fmt

Reusable format strings for format! and friends

chema

An external DSL for JSON Schema

cluFullTransmute

A more complete and advanced version of data transmutation without restrictions

actix-web-codegen

Routing and runtime macros for Actix Web

labhub

Bot for running builds against GitHub with GitLab CI

twyg

A tiny logging setup for Rust applications

kailua_langsvr_protocol

Language server protocol types for Kailua

chalk-ir

Chalk’s internal representation of types, goals, and clauses

orbclient

The Orbital Client Library

report-test

A simple interface to get a local SGX attestation (“report”). This is useful for testing remote attestation

rustlex_codegen

Syntax extension for RustLex

zenkit-codegen

Generate Zenkit ORM client in Rust from user-defined workspace schema

ct-python

Execute Python code at compile time to generate Rust code

oe

OE is a macro to make errors easy and expressive

shaku_derive

Code generation for the shaku dependency injection framework

tokio-tls-helper

Utility tool to make TLS easy to use. Most of the code is extracted from tonic.

lark

Lark programming language, a Salsa-based compiler experiment

runner

Utility for running Rust snippets

belay

Run your CI checks locally to git push with confidence

constany_stage_one

Convert any function to constant

constany_stage_two

Convert any function to constant

semantic-rs

Automatic crate publishing

plumber-rs

The basic library for Plumber servlet written in Rust

fakes-gen

This CLI tool is generate dummys whose option you specified. You can also specify formatter for csv, tsv and json. This program support multi-locale. When not support your locale and you want your locale faker…

rustfmt_lib

Rustfmt as a library

wasm-gc-api

A library to garbage collect webassembly modules

scrumple

A fast JavaScript bundler for Origami components

repoutil

Wrapper around my common git commands

msvc-demangler

A rust library that demangles / undecorates C++ symbols mangled by MSVC

rustfmt

Tool to find and fix Rust formatting issues

if_rust_version

Macro to enable or disable code depending on the rust version

tetsy-wasm-gc-api

A library to garbage collect webassembly modules

mlzlog

A collection of log4rs tools to log like the mlzlog Python package

yanker

A Rust crate to automate crate-yanking

hyeong

Hyeo-ung Programming Language Compiler

genesis

A library for generating statically-typed ECS worlds

butido

Linux package tool utilizing docker, postgres and toml

hygeia

Python toolchain manager 🐍

endbasic-std

The EndBASIC programming language - standard library

c2rust-refactor

C2Rust refactoring tool implementation

bpf-linker

BPF static linker

auditable

Audit Rust binaries for known bugs or vulnerabilities in production with zero bookkeeping

apify-client

Typed wrapper for Apify API

koifish

Koifish

kx

Interactively switch between kubernetes contexts without any external dependencies

zamm_yang

A basic, experimental code generator

dirmod

Automatic mod declarations

nar

Narc, a dependently-typed programming language with dependent pattern matching

tugger-wix

Interfaces to the WiX Toolset to produce Windows installers

dockerfile

A Rust library for dynamically generating Dockerfiles

runtime_injector

Runtime dependency injection container

rocket_codegen

Procedural macros for the Rocket web framework

fractran_macros

A compiler plugin that converts Fractran code into Rust at compile time, letting your Fractran programs be optimised by LLVM to super-fast native code

code-tour

Enhanced example-based learning, i.e. awesome examples user experience

project-root

Simple utility to return the absolute path to your project root

alfred-crates

Workflow for searching Rust crates from Alfred

fuzzcheck_mutators

Basic mutators for fuzzcheck-rs

cbor-smol

Streamlined serde serializer/deserializer for CBOR

lsif-types

Types representing Language Server Index Format (LSIF) elements

new-rust-project

@ErichDonGubler’s fancy template for new Rust projects

koto

A simple, expressive, embeddable programming language

mergereq

CLI for Gitlab merge requests & more

ketos

Lisp dialect scripting and extension language

ritual_build

Build script implementation for C++ library wrappers

zamm

A literate programming tool for Yin and Yang

tetsy-wasm-gc

A CLI tool to garbage collect webassembly modules

async-prost

deploy

The deploy library to aide writing and debugging of distributed programs, as well as tooling to run them across a cluster

git-cf

This is a git extension which compresses files into one file and also restores them from it. It is useful when you need to work with files which is unfamiliar to git, such as binary files or security ones.

cargo-rustc-cfg

Runs the cargo rustc -- --print cfg command and parses the output

dirmod-codegen

Automatic mod declarations

feature-probe

Probe for rustc features from build.rs

bfc-rs

A Brainfuck compiler for x86-64 Linux implemented in Rust

hyoka

Generic REPL that can be configured to do pretty much anything you want

selectel-mks

Rust SDK for the Selectel Managed Kubernetes Service

hotpatch_macros

Macros for hotpatch

utigo

Utigo, a package manager for C++

rtlola-hir

A high-level intermediate representation for RTLola specifications

kari

An embeddable programming language, writting in and for Rust

gwd-backend-firefox

Firefox backend for Godwit-Daemon

ptx-builder

NVPTX build helper

pkg

A small utility library for binary applications

caller_modpath

Get the module path of the caller in a proc_macro

sexpy

Automatically derivable s-expression parsers for simple programming languages

malory

A tool to benchmark Async Functions (Futures)

libhandy-sys

The sys part of the rust bindings for libhandy

camo

Foreign language interface generation

cluuname

Library for displaying information about the system

runestick-macros

Runescript, a generic stack-based virtual machine for Rust

complexity

Calculate cognitive complexity of Rust code

get-random-const

Simple compile-time random generator

clippy_lints

A bunch of helpful lints to avoid common pitfalls in Rust

certainly

The easiest way to create self-signed certificates. Ever.

kailua

🌴 Type Checker and IDE Support for Lua

fprint

Flushed print

dux

X11 backlight manager

xhypervisor

Hardware-accelerated virtualization on OS X

jilu

Generate a change log based on conventional commits

wilton_rusty

Rust modules support for Wilton JavaScript runtime

obelix

Obélix is a tool to reduce Rust source files to produce MVEs

rusty-cheddar

A library to automatically generate C header files from Rust source files

is_true

Is it true?

ninja-metrics

A simple RAII based metrics gathering crate created for ninja-rs but usable independently

turtle-lang

A humble, fun, and friendly Lisp

grust

GObjectIntrospection bindings for Rust. This is the core library providing basic functionality to all generated crates

assembly-core

Core functionality of the assembly crate

llvm-rs

A wrapper for LLVM, a powerful library and toolkit for compilers

hy

Hydrogen (hy) is a build system…. for the modern world!

sp-xml

A library for IBM Safer Payments® XML messages serialization/deserialization

coolq-sdk-rust

A sdk for coolq

robust-git-bisect

Robust Git Bisect provides an alternative to git bisect which is robust against errors during the search

classreader

A Rust library that reads, writes, and parses Java Virtula Machine class files

llvm-sys-featured

Bindings to LLVM’s C API

libmaj

A library to create installers and updaters

alt_semver

Semantic version parsing and comparison

dec

A decimal arithmetic library providing high-level, safe bindings to libdecnumber

wright

The rust package and API for the wright programming language

crev-common

Scalable, social, Code REView system that we desperately need - common code

khaki

A tool to write rust scripts with less boilerplate

k8-obj-core

Core Kubernetes API Objects

docker-puzzles

Docker Puzzles is a CLI tool for putting together Dockerfiles from pieces

tracing-callgraph

A tracing library for generating call graphs from spans

build-helper

This crate contains convenience methods for build scripts

deno_cli_snapshots

Provides snapshots for the deno CLI

finn-assembler

The Finn IR Assembler

cmdparser

A simple argument parser for Rust

cargo-culture-kit

Library for writing tools that check Rust project conventions

install-framework-gui

[Install Framework] GUI interface powered by iced

gw

gw - gradlew convenience - gdub clone

cargo-suicide

Tool to fix your code forever

trivial-compiler

The Trivial compiler framework for Metamath Zero binary proofs

charj

Charj is a language for describe other languages

statsdproto

Building blocks to parse, transform, and even pass through statsd data

git-changelog

A tool to automate project changelog generation

load_file

Macros to help conveniently load the contents of files during development

tg-bot-api

Telegram Bot API parser

install-framework

A simple and lightweight cross-platform install framework written in Rust

rusty-asm

A layer of syntactic sugar between Rust and inline assembly

codespawn

C++ and Rust code generator. Supports XML and JSON for API definitions.

uvm_core

The core functionality for the unity version manager commandline client

brainfuck_macros

A compiler plugin that converts brainfuck code into Rust at compile time, letting your BF programs be optimised by LLVM to super-fast native code

devbox-test-args

Parametrized tests macro

enum-utils

A set of useful proc macros for enums

koto_cli

A CLI and script runner for the Koto programming language

burst

A disassembler, currently supporting x86

kailua_langsvr

Language server implementation for Kailua

heliotrope

SOLR client for Rust programming language

ein-ffi

FFI library for Ein programming language

check-versions

Simple crate for ensuring that version numbers in README files are updated when the crate version changes

json-parser

JSON parser

minitt-util

CLI Utilities extracted from Mini-TT language’s type-checker

build_id

Obtain a UUID uniquely representing the build of the current binary

fix-getters-utils

Utils for fix-getters

mobc-tonic

A connection pool for tonic GRPC client

opsgenie-rs

Rust client for OpsGenie API

tfdoc

Generate Terraform module documentation

svd_codegen

Generate Rust register maps (structs) from SVD files

docker-generate

docker file read/write

dia-kit

Some kit

pop-os/tensorman

Tensorflow Docker Container Manager

cargo-fuzzcheck

Command line tool to use fuzzcheck-rs

ux-compiler

UX Framework Complier

hypervisor

Hardware-accelerated virtualization on OS X

dhi-xml

A library for TSYS DHI (Device Host Interface) XML messages serialization/deserialization

hotpatch

Changing function definitions at runtime

moss

Experimental Moss interpreter

typestates

macro_rules! to build typestates

nbytes

Rust compile-time evaluation of byte unit conversions

darkweb-dotenv

A library that eases configuration via .env environment files

types

Type condtions

gitconfig2json_cli

Parse git config --list --null for cli

splits_iter

Iterator over all 2-splits

bee-runtime

Runtime components and utilities for the bee framework

camo-derive

Camo derive macro

text2checkstyle

text to checkstyle

herbie-lint

A rustc plugin to check for numerical instability

xasm

Compiler for the xasm programming language

ruwren-sys

Low-level bindings to Wren programming language. Not affiliated with the main team for Wren.

bele

Big-Endian Little-Endian

rtlola-parser

A parser for RTLola specifications

repo-backup

A program for backing up your GitHub and GitLab repos

luajit2-sys

LuaJIT-2.1 FFI Bindings

easy-plugin

A compiler plugin that makes it easier to write compiler plugins

swagg

Code generator from swagger file for actix-web framework

rustc-cfg

Runs rustc --print cfg and parses the output

javascriptcore-sys

Raw bindings to the JavaScriptCore framework

gitlab-ci-validate

Checks if your .gitlab-ci.yml file is valid

gradle-sync

Small utility to synchronize the gradle version with the cargo version

rust-gh-example

Example of Rust GitHub template

config-tree

Configuration framework using subtrees

crate_version_parse

simply parses crate-semver from a string

adapton-lab

Testing and performance evaluation suite for Adapton

is_false

Is it false?

trans-schema

Generating trans schema from Rust code

rune-macros

Helper macros for Rune

spalm

Specification Project of E5R Application Lifecycle Management

transporter

A code generator for type-safe APIs

prometheus-wire

A simple library to query and parse metrics from Prometheus exporters

glissile

A macro for generating GLSL source code

rust-libindy-wrapper

A library for assisting developers using LibIndy API

falcon-raptor

Higher-level semantics over Falcon IL

datadog-workflow

Datadog Alfred Workflow to search dashboards, screenboards and monitors

trans-gen-java

Generating Java trans code

brainheck

Brainheck interpreter written in Rust

rhq-core

Core library for rhq

tagua-llvm

Safe LLVM bindings

must-implement-trait

An attribute proc-macro which enforces that a type (auto-)implements the specified trait(s)

tarp

Tarp is a code coverage tool

cargo-src

Semantic code navigation for Rust

ecp

easily build compiler plugins

docmatic

Test Rust examples in your documentation

jq-sys

Generated bindings for libjq

kudubot-bindings

Rust Bindings for the kudubot framework

lsystems

A simple library for working with Lindenmayer systems

dbgtools

Expensive and intrusive debugging tools

cargo-culture

Tool to check Rust project conventions

rust-releases-io

I/O helper crate for rust-releases

cluatoi

Parsing the byte sequence of the ascii characters and safely converting them to integers

waiter

Simple waiter trait for synchronous events

ninjars

A rust implementation of the ninja build system. This is the main application. This one is built on the theory in Build Systems a la Carte.

bitbash

Macros for working with bitfields

bake

A containerized build system

plykit

Implementation of ply specification

cl-traits-derive

Derives for cl-traits

rthrift_tutorial

rthrift server & client tutorial :)

rerust

Reactive programming with dataflow semantics

koto_serialize

Serde serialization support for the Koto programming language

libjess

Utility library for daily tasks

st-cli

Dev Super Tools! auto format & lint and more

bitbash-macros

proc-macro crate for bitbash

sdk-cds

SDK in Rust to use CDS API

spm_precompiled

This crate aims to emulate https://github.com/google/sentencepiece Dart::DoubleArray struct and it’s Normalizer. This crate is highly specialized and not intended for general use.

mech-stats

Statistics library for the Mech language

loalang

Loa is a general-purpose, purely immutable, object-oriented programming language

MBrane

MBrane implementations in Rust

uvm_move_dir

Opinionated directory move operation

missing_mpl

A lint for watching over your project’s MPL-2.0 licensed source files

subtree

Configuration framework using subtrees

oxur-component

Enabling the creation of application components with lifecycle and dependency support

gamemap

A small 2D Map library for console games in Rust

mdl_monkey

A Rust implementation of the Monkey programming language from https://interpreterbook.com/

ptail

Stream and display a fixed number of lines from a processes output

trans-gen-go

Generating Go trans code

reups

A clean implementation of the eups package management system in rust

termination

Library that exposes Termination trait, similar to std::process::Termination

nvptx

Rust to PTX compiler using LLVM/NVPTX target

d5

The simple, Unix-philosophy tool to retrieve your home network’s IP address remotely

unwrap_to

A utility macro to unwrap enums

caller_modpath_macros

proc_macros for caller_modpath