Rust crates of the week

All Rust's crates of the weeks, from the This Week in Rust newsletter, on a single page.

2024

(577) include-utils, a more powerful replacement for the standard library's include_str macro.
(576) augurs, a time-series toolkit for Rust with bindings to JS & Python.
(575) postcard, a battle-tested, well-documented #[no_std] compatible serializer/deserializer geared towards use in embedded devices.
(574) fixed-slice-vec, a no-std dynamic length Vec with runtime-determined maximum capacity backed by a slice.
(573) struct-split, a proc macro to implement partial borrows.
(572) wtransport, an implementation of the WebTransport specification, a successor to WebSockets with many additional features.
(571) tower-http-client, a library of middlewares and various utilities for HTTP-clients.
(570) trait-gen, an attribute macro to generate the trait implementations for several types without needing custom declarative macros, code repetition, or blanket implementations.
(569) bacon, a terminal application to run your cargo tasks on change in background.
(568) float8, an 8-bit float implementation.
(567) binsider, a terminal UI tool for analyzing binary files.
(566) perpetual, a self-generalizing gradient boosting implementation.
(565) lepton-jpeg-rust, Microsoft's port of Dropbox' lepton space-saving JPEG compressor library to Rust.
(564) cargo-override, a cargo plugin for quick overriding of dependencies.
(563) vimania-uri-rs, a VIM plugin for file and URI handling.
(562) wtx, a batteries-included web application framework.
(561) discret, a graphQL-based peer-to-peer implementation library.
(560) rencfs, a FUSE-based encrypted filesystem for Linux.
(559) WhenFS, a FUSE filesystem that misuses your google calendar as storage. And yes, your schedule will look as packed as mine once you store one or two files in there.
(558) static-keys, a nightly-only mechanism to speed up checks of rarely changed features and bon, yet another crate to autogenerate builders from functions, methods and structs.
(557) diatomic-waker, a spinlock-less library for async task wakeup.
(556) cargo-wizard, a cargo subcommand that applies profile and config templates to your Cargo project to configure it for maximum performance, fast compile times or minimal binary size.
(555) derive_deflty, a proc macro to create derive macros from declarative code.
(554) asak, a terminal-based audio recording/playback TUI.
(553) cargo-binstall, a cargo subcommand to install crates from binaries out of their github releases.
(552) yazi, a blazing fast terminal file manager based on async I/O.
(551) hydra, an actor framework inspired by Erlang/Elixir.
(550) layoutparser-ort, a simplified port of LayoutParser for ML-based document layout element detection.
(549) pulso, a simple metrics collector for TCP/IP.
(548) ralertsinua, a text user interface for getting information about Russian air raids in Ukraine.
(547) stated-scope-guard, a library supporting a more flexible RAII pattern for stated resouce management.
(546) derive_more, for deriving a whole lot of traits.
(545) efs, a no-std ext2 filesystem implementation with plans to add other file systems in the future.
(544) scandir, a high-performance file tree scanner.
(543) venndb, an append-only memory DB whose tables can be build via a derive macro.
(542) archspec-rs, a library to track system architecture aspects.
(541) cargo-unfmt, a formatter that formats your code into block-justified text, which sacrifices some readability for esthetics.
(540) coffee-break, the premier crate for those who think Rust compile times are too fast.
(539) heck, a no_std crate to perform case conversions.
(538) biscotti, an opinionated library to deal with HTTP cookies on the server side.
(537) srgn, a mix of tr, sed, rip-grep and tree-sitter.
(536) web-audio-api-rs, a Rust implementation of the Web Audio API for use outside the browser.
(535) kind, a helper crate for typed UUIDs.
(534) microflow, a robust and efficient TinyML inference engine for embedded systems.
(533) embedded-cli-rs, a library that makes it easy to create CLIs on embedded devices.
(532) Apache Iceberg Rust, a Rust implementation of a table format for huge analytic datasets.
(531) apistos, an OpenAPI documentation tool.
(530) fish, a friendly interactive shell that used to be written in C++, but was recently rewritten in Rust (though admittedly they'll have to do some work until it hits your distro's repos).
(529) named-sem, a wrapper library for named semaphores on Linux & Windows.
(528) fast_pool, a fast async pool based on the flume channel crate.

2023

(527) rouille, a small synchronous web framework.
(526) constcat, a std::concat!-replacement with support for const variables and expressions.
(525) io-adapters, lets you convert between different writeable APIs (io vs. fmt).
(524) symbols, a utility to quickly create proc-macros to solidify database tables into enums enabling compile time foreign key checks.
(523) tokio-graceful, a library for graceful shutdown of tokio-based async servers.
(522) rocket, an opinionated web framework that aims to be really ergonomic while still being fast.
(521) cargo-msrv, a cargo subcommand to find out the Minimum Supported Rust Version (MSRV) of your crate.
(520) floem, a native Rust UI library with fine-grained reactivity.
(519) silkenweb, a library for building web apps with fine-grained reactivity and a clean separation of logic and UI.
(518) cargo-show-asm, a cargo subcommand to show the optimized assembly of any function.
(517) rinf, a library to write Rust in Flutter.
(516) yarer, a library and command-line tool to evaluate mathematical expressions.
(515) loole, another multiple-producer multiple-consumer channel.
(514) async_fn_traits, a crate with async function traits to enable using higher ranked trait bounds in async functions.
(513) RustQuant, a crate for quantitative finance.
(512) rs-env, a hierarchical environmant variable manager.
(511) str0m, a synchronous sans-IO WebRTC implementation.
(510) dprint, a fast code formatter that formats Markdown, TypeScript, JavaScript, JSON, TOML and many other types natively via Wasm plugins.
(509) document-features, to extract documentation for the feature flags from comments in Cargo.toml.
(508) agree, a command-line tool implementing Shamir's Secret Sharing.
(507) deep_causality, a hyper-geometric computational causality library.
(506) allocator-api2, a forward-compatibility shim to use the nightly allocator API on stable Rust.
(505) tower-async, a currently nightly-only async library to build network servers, based on tower.
(504) ratatui, to build rich terminal user interfaces and dashboards.
(503) dusk, a nice df like utility to display the fill level of your disks.
(502) rustypaste, a minimal file upload/pastebin service.
(501) Parsel, an easy to use parser generator.
(500) release-plz, a crate to automate changelog generation, GitHub/Gitea release tagging, publishing on crates.io and bumping the version.
(499) mailtutan, a simulating SMTP server.
(498) kanata, a keyboard remapper for Linux and Windows.
(497) progenitor, an OpenAPI client generator with support for strongly typed mock tests.
(496) whichlang, a fast no-dependencies OSS natural language detector.
(495) Qdrant, an open source production ready vector database/similarity search engine written in Rust.
(494) dlhn, a serde-compatible serialization format geared for performance.
(493) script-macro, an experimental way of writing simple proc-macros inline.
(492) system-deps, a crate that will compile your pkg-config-based dependencies for you.
(491) onlyerror, a #[derive(Error)] macro with support for no_std on nightly compilers.
(490) spacedisplay, a small terminal app for analyzing used disk space.
(489) keshvar, a library providing a host of information on every country.
(488) typst, a modern LaTeX replacement.
(487) Speedy2D, offering cross-platform Hardware-accelerated drawing of shapes, images, and text, with an easy to use API.
(486) duplicate, a proc macro crate for easy parametric code duplication.
(485) man-in-the-middle-proxy.
(484) goku, a HTTP load tester.
(483) darkbird, a high-concurrency real-time in-memory database (darkbird again???? wtf!).
(482) bkmr, a fast CLI bookmark manager and launcher.
(481) envious, a serde-based deserializer from environment variables.
(480) symphonia, a collection of pure-Rust audio decoders for many common formats.
(479) darkbird, a mnesia-inspired high concurrency, real time, in-memory storage library.
(478) syntactic-for, a syntactic "for" loop Rust macro.
(477) schnellru, contains a fast and flexible LRU map.
(476) Sniffnet, a cross-platform GUI application to analyze your network traffic.

2022

(475) scraper, a crate for HTML parsing and querying with CSS selectors.
(474) dhat, a crate providing DHAT-like allocation profiling capabilities.
(473) lazy_format, a lazy version of format! for more efficient composed string formatting operations.
(472) zeroize, to securely clear secrets from memory either manually or on drop, with both methods for your types being but one #[derive] away.
(471) code-radio-cli, a command line interface for listening to freeCodeCamp's Code Radio music stream.
(470) graph, a collection of high-performance graph algorithms.
(469) lngcnv, a linguistic command line tool.
(468) enum_delegate, a crate to replace dynamic dispatch with enum dispatch.
(467) type_description, to make types discoverable for users by explaining them in a way that a user can understand without knowing implementation details.
(466) humantime, a parser and formatter for std::time::{Duration, SystemTime}.
(465) HyperQueue, a runtime for ergonomic execution of programs on a distributed cluster.
(464) pci-driver, to develop user-space PCI(e) linux drivers.
(463) humansize, a size formatting crate.
(462) serde-transcode, to efficiently convert between various serde-supporting formats.
(461) match_deref, a macro crate to implement deref patterns on stable Rust.
(460) bstr, a fast and featureful byte-string library.
(459) sql-query-builder, a library to write SQL queries in a simple and composable way.
(458) bytehound, a memory profiler for Rust.
(457) sass-embedded, a library to communicate with Embedded Dart Sass.
(456) cargo-pgo, a cargo subcommand to compile your code with profile-guided optimization and BOLT for good measure.
(455) fang, an async background processing crate.
(454) lending-iterator, a type similar to std::iter::Iterator, but with some type trickery that allows it to .windows_mut(_) safely.
(453) cargo-semver-checks, a CI-friendly tool to check your library's API.
(452) bnum, a library of arbitrarily sized fixed-size numerals.
(451) shame, a shader EDSL for writing render and compute pipelines.
(450) coprosize, a program to aiding the study of dinosaur dung.
(449) cap-std, a std-replacement that introduces capabilities to facilitate defense-in-depth sandboxing.
(448) error_stack, a currently nightly-only error handling library that optimizes for ease of use while allowing to add arbitrary context data to errors..
(447) dxf-rs, a library to parse AutoCAD files.
(446) osmpbf, an OpenStreetMap pbf-file reader.
(445) pgfplots, a crate to generate publication-quality figures (with or without LaTeX).
(444) rustdoc-types, a crate with types to deserialize Rustdoc's JSON output.
(443) cargo-supply-chain, a cargo subcommand to gather author, contributor and publisher data on crates in your dependency graph.
(442) enum_dispatch, a proc-macro-attribute to replace dynamic dispatch with enum dispatch to gain performance.
(441) shuttle, a declarative deployment solution for and at your service.
(440) czkawka, a GTK-based duplicate finder.
(439) ttrpc, a GRPC-like protocol implementation for memory-constrained environments.
(438) hifitime, a high fidelity time management library.
(437) bet, a library of binary expression trees.
(436) lapce, a lightning-fast powerful code editor.
(435) heph, an event-driven, non-blocking I/O, share-nothing actor framework.
(434) noline, a small no-std compatible readline-like line editor.
(433) cfb to read/write Compound File Binary (structured storage) files.
(432) prae, a crate with macros to define types with inbuilt invariants.
(431) cargo-nextest, a fast test runner.
(430) assay, a test macro that puts each test in its own process and filesystem.
(429) document-features, a small proc macro to parse your Cargo.toml and generate docs for your features.
(428) update-informer, a library to embed an update check into your CLI project and blake3, a fast cryptographic hash function.
(427) html5gum, a WHATWG HTML spec-compliant HTML5 tokenizer.
(426) cargo-release, a cargo subcommand that makes every crate release a breeze.
(425) rustix, with safe bindings to POSIX-ish syscalls.
(424) fltk-rs, with bindings to the FLTK GUI toolkit.

2021

(423) zoxide, a smarter cd command.
(422) kajiya, an experimental real-time global illumination renderer made with Rust and Vulkan.
(421) efg, a proc macro to allow boolean expression like syntax for #[cfg]s.
(420) tap, a library with extension traits to provide suffix-position pipeline behavior.
(419) poem-openapi, a framework to implement OpenAPI services.
(418) rustc_codegen_nvvm, a rustc codegen backend that targets NVIDIA's libnvvm CUDA library.
(417) starship, a fast featureful customizable UNIX terminal prompt.
(416) chumsky, a friendly parser combinator crate.
(415) roogle, a type-based Rust API search engine inspired by Haskell's Hoogle.
(414) cargo-crev, a tool to distribute security review of the crates we all depend on.
(413) serde_with, helper macros to ease implementing serde traits for your types.
(412) flutter_rust_bridge, a memory-safe binding generator for Flutter/Dart ↔ Rust.
(411) pubgrub, a Rust implementation of the state of the art version solving algorithm.
(410) miette, a library for error handling that is beautiful both in code and output.
(409) flowistry, a VS code extension to visualize data flow in Rust code.
(408) qcell, with a type that works like a compile-time RefCell.
(407) gradient, a command line tool to extract gradients from SVG, display and manipulate them.
(406) cargo-llvm-cov, a cargo subcommand for LLVM-based code coverage.
(405) kube-leader-election, a crate to implement leader election for Kubernetes workloads.
(404) synth, a declarative test data generator written in Rust.
(403) ockam, a crate to implement transport-agnostic end-to-end encryption for the rest of us.
(402) sycamore, for making web applications using WebAssembly.
(401) loadstone, a bare-metal bootloader for embedded systems.
(400) dylint, a tool for running Rust lints from dynamic libraries.
(399) endbasic, an emulator friendly DOS / BASIC environment running on small hardware and the web.
(398) css-inline, to inline CSS into style tags.
(397) hypergraph, graph data structure implementation where edges can join arbitrary numbers of vertices.
(396) serde-encrypt, adds encryption to all Serialize impls.
(395) 1) nativeshell gets you a Flutter app in Rust, 2) static-rc is a compile-time reference-counted smart pointer.
(394) cargo-sort, a cargo subcommand to sort your Cargo.toml's dependencies and workspace members.
(393) rustc-codegen-gcc, a drop-in replacement for the LLVM-based rust compiler backend targetting GCC.
(392) typed-index-collections, lets you make Vecs with custom-typed indices.
(391) arraygen, a derive proc macro to generate arrays from structs.
(390) tokio-console, a "top"-like utility to view your tasks run.
(389) display_utils, a library with Displayable structs to make string manipulation easier.
(388) cargo-rr, a cargo subcommand to use the time-traveling rr debugger on our code.
(387) deltoid, for delta-compressing Rust data structures.
(386) dipa, to derive delta-encoding for Rust data structure.
(385) rs_pbrt, a counterpart to the PBRT book's (3rd edition) C++ code.
(384) tide-acme, for automatic HTTPS certificaion using Let's Encrypt for Tide.
(383) egg, a project using e-graphs to provide a new way to build program optimizers and synthesizers.
(382) ibig, fast big integers.
(381) sorceress, a Rust environment for sound synthesis and algorithmic composition.
(380) camino, a library with UTF-8 coded paths mimicking std::os::Path's API.
(379) lever, a library for writing transactional systems.
(378) firestorm, fast intrusive flamegraph profiling.
(377) thread_io, makes disk IO in a background thread easy and elegant.
(376) fancy-regex, a regex implementation using regex for speed and backtracking for fancy features.
(375) aquamarine, inline diagrams for rustdocs.
(374) dotenv-linter, a lightning fast linter for .env files.
(373) fast-float, provides methods to parse floats really fast.
(372) nom-supreme, utilities for nom parsers, especially for great parse error handling.

2020

(371) autograd, a library of differentiable operations and tensors for machine learning applications.
(370) RustFFT, a mixed-radix FFT implementation.
(369) thermite, a SIMD struct-of-arrays-algorithms library.
(368) breadx, a X-windows protocol implementation in 100% safe and mutex-free Rust.
(367) kira, a library for expressive game audio with many bells and whistles.
(366) cargo-intraconv, a cargo subcommand to convert links in rust documentation to the newly stable intra-doc-links format.
(365) lingua, a ngrams-based natural language detector.
(364) postfix-macros, a clever hack to allow postfix macros in stable Rust.
(363) tract from Sonos, a neural network inference library, written purely in Rust for models in ONNX, NNEF and TF formats.
(362) rust-gpu from Embark Studios, a system to compile Rust code into Vulkan graphics shaders (with other shader types to follow.
(361) icu4x, the Unicode Consortium's official crate for dealing with i18n in resource constrained environments.
(360) paste, a macro to concatenate identifiers (which would otherwise be nightly only).
(359) uniffi, a unified ffi binding generator for Rust.
(358) fs-err, a library to make filesystem errors usable.
(357) cargo-about, a handy cargo subcommand to list the dependencies and their licenses!
(356) gitoxide, an idiomatic, modern, lean, fast, safe & pure Rust implementation of git.
(355) serde-query, an efficient query language for Serde.
(354) GlueSQL, a SQL database engine written in Rust with WebAssembly support.
(353) pdf, a crate for reading PDF files.
(352) cargo-c, a cargo subcommand to build and install C-ABI compatibile dynamic and static libraries.
(351) bevy, a very capable yet simple game engine.
(350) partial-io, a set of helpers to test partial, interrupted and would-block I/O operations.
(349) polyfuse, a library for writing FUSE file systems using async code.
(348) pre, a library for declaring and checking the assurance of precondition, useful for unsafe functions.
(347) nnnoiseless, a filter for audio noise removal ported from C.
(346) suckit, a tool to recursively download a website.
(345) print_bytes, a library to print arbitrary bytes to a stream as losslessly as possible.
(344) diskonaut, a disk usage explorer.
(343) safer-ffi, a library to help write safe FFI code.
(342) cargo-spellcheck, a cargo subcommand to spell-check your docs.
(341) jql, a JSON Query Language CLI tool.
(340) cargo-asm, a cargo subcommand to show the resulting assembly of a function. Useful for performance work.
(339) apply, for chaining free functions into method call chains.
(338) cargo-workspaces, a cargo subcommand to manage your cargo workspace.
(337) winrt, Microsoft's Rust/WinRT language projection.
(336) coercible_errors, a library that allows generic trait implementations to omit the size cost of Result::Err if errors never happen.
(335) regex2fat, a program to convert a regular expression into a decidedly nonstandard FAT32 file system. Funny.
(334) sudo, a library to let your program run as root.
(333) explaine.rs, an interactive Rust syntax playground.
(332) async-recursion, a macro to allow recursion in async functions.
(331) flume, a fast multi-producer single-consumer channel.
(330) beef, an alternative memory-compact Clone on Write (CoW) implementation.
(329) plotly, a plotly.js-backed plotting library.
(328) tokenizers, Python & NodeJS bindings for fast text tokenization for machine learning.
(327) wundergraph, a GraphQL interface library, and kibi, a text editor in thousand lines of Rust.
(326) pointer-utils, for working with pointers, and jlrs, to call Julia from Rust.
(325) argh, a small opinionated argument parsing library for Rust.
(324) faux, a trait-less mocking library for Rust.
(323) test-case, a framework for parameterized testing.
(322) fasteval, for fast and safe evaluation of algebraic expressions.
(321) cxx, to build a C++ FFI safely by taking care of both sides.
(320) sqlx, a modern SQL client library.

2019

(319) attohttpc, a tiny synchronous HTTP client library.
(318) bstr, a cargo subcommand to run clippy on only the changed code in your crate (following git diff).
(317) bstr, a string type for Rust that is not required to be valid UTF-8.
(316) StaticVec, a nightly-only const-generics-backed fixed size vec crate.
(315) joinery, a library for generic string joining.
(314) rerast, a rule-based Rust code transformation tool.
(313) wasmtime, a standalone JIT-style runtime for WebAssembly.
(312) 1) accurate, accumulator types for more accurate (or even provably correct) sum and dot product of floating-point numbers. 2) transfer, a crate to transfer values between pinned instances. 3) genawaiter, a crate to allow generators on stable Rust. a procedural derive macro to implement Display by string-interpolating the doc comment.
(311) displaydoc, a procedural derive macro to implement Display by string-interpolating the doc comment.
(309) grubbnet, a TCP client/server library for networked applications and games.
(308) 1) Watt, a fast WASM-based proc-macro runtime, 2) Anyhow, yet another error handling crate, and 3) spotify-tui, a console user interface for Spotify.
(307) algebraics, a pure-Rust algebraic numbers library for infinite-precision computation.
(306) pin-project, a proc-macro-derive for ergonomic and safe Pin projections.
(305) runtime, an experimental hot-reloading oriented runtime in Rust.
(304) texture-synthesis, a program to generate textures by choosing examples.
(303) viu, a terminal image viewer.
(302) cargo-udeps, a cargo subcommand to find unused dependencies.
(301) include_flate, a variant of include_bytes!/include_str with compile-time DEFLATE compression and runtime lazy decompression.
(300) async-std, a library with async variants of the standard library's IO etc.
(299) topgrade, a command-line program to upgrade all the things.
(298) broot, a program to show the gist of a directory tree.
(297) async-trait, a procedural macro to allow async fns in trait methods.
(296) abscissa, a security-oriented Rust application framework.
(295) overloadable, a crate to provides you with the capabilities to overload your functions in a similar style to C# or C++, including support for meta attributes, type parameters and constraints, and visibility modifiers.
(294) rustexp, a website to edit and test Rust regular expressions.
(293) aljabar, an extremely generic linear algebra libary (nightly only).
(292) winit, a pure-rust cross-platform window initialization library.
(291) safe, a #[safe] attribute for explaining why unsafe { ... } is OK.
(290) uom, units of measurement, a crate that does automatic type-safe zero-cost dimensional analysis.
(289) emu, a Rust-based language for programming GPUs.
(288) mockiato, a strict yet friendly mocking library for Rust 2018.
(287) memory-profiler, does what it says on the box. momo is a procedural macro that outlines generic conversions to reduce monomorphized code.
(286) panic_never, a crate to make every panic a link-time error.
(285) select-rustc, a crate for conditional compilation according to rust version.
(284) cast-rs, a crate with ergonomic, checked cast functions for primitive types.
(283) color-backtrace, a crate to give panic backtraces more information (and some color, too).
(282) send-fd, a simple way to send file descriptors over UNIX sockets.
(281) interact, a framework for online introspection of the running program state.
(280) sonic, a fast, lightweight & schema-less search backend.
(279) safety-guard, a crate providing a #[safety] attribute that generates both a doc entry and a debug assertion.
(278) copyless, a crate to extend boxes and vets to operate on values while avoiding memcpys.
(277) validator, a crate offering simple validation for Rust structs.
(276) multi_try, a crate to simplify working with multiple results.
(275) shellfn, a proc macro to easily and safely use shell scripts in Rust.
(274) num-format, a crate to format numbers to international standards.
(273) sysinfo, a system handler to get information and interact with processes.
(272) log-derive, a procedural macro to log function outputs.
(271) typetag, a small crate to allow serde trait objects.
(270) rust-analyzer, an experimental Rust compiler frontend for IDEs.
(269) ropey, an editable text buffer data structure.
(268) gfx-hal, a hardware abstraction for fox-rs.
(267) Dose Response, an online-playable tonguelike game with a probably bleak outcome.

2018

(266) sandspiel, a WASM-powered online sandbox automaton game.
(265) yasered, a specialized (de)serialisation crate compatible with serde
(264) lsd, a colorful and fast ls replacement.
(263) cargo-call-stack, a cargo subcommand for whole-program call stack analysis
(262) modulator, a crate of abstract modulators for use in audio synthesizers (and possibly elsewhere).
(261) cargo-sweep, a cargo subcommand to clean cargo's various temporaries.
(260) cargo-nono, a cargo subcommand to check a crate's dependencies for no-std compatibility.
(259) parse_wiki_text, a crate to parse MediaWiki entries into a tree of elements.
(258) dutree, a command line tool that produces a colorful tree view of your disk usage.
(257) static-assertions, a crate that does what it says on the tin – allow you to write static assertions.
(256) noria, a new streaming data-flow system designed to act as a fast storage backend for read-heavy web applications.
(255) pest, Parsing Expression Grammar-based parser library.
(254) evcxr, a Rust REPL and Rust Jupyter Kernel.
(253) packed_simd, a crate with portable SIMD vector types
(252) mtpng, a paralllized PNG encoder.
(251) cargo-src, a Rust source browser with syntax highlighting, jump to def, smart search and much more.
(250) cgroups, a native Rust library for managing control groups under Linux.
(249) generational-arena, a safe arena allocator that allows deletion without suffering from the ABA problem by using generational indices.
(248) wasm-bindgen-futures, a crate to make ECMAScript promises and Rust futures interoperate.
(247) macro_railroad, a library to create neat syntax diagrams for macro_rules! declarative macros.
(246) warp, a fast, composable web framework.
(245) Taizen, a wikipedia browser for your terminal.
(244) rav1e, the fastest and safest AV1 encoder from Xiph.Org Foundation
(243) paste, a self-hosted pastebin made of a lot of Rust and a little Ruby.
(242) cargo-geiger, which detects usage of unsafe Rust in your project and its dependencies.
(241) datafrog, the lightweight embeddable datalog engine that powers Rust's non-lexical lifetimes (NLL).
(240) mutagen, a mutation testing framework for Rust.
(239) SIMDNoise, a crate to use modern CPU vector instructions to generate various types of noise really fast.
(238) clap-verbosity-flag, a small crate to easily add a verbosity setting to Rust command line applications.
(237) im, a library for immutable data structures in Rust.
(236) syntect, a library for syntax highlighting using Sublime Text syntax definitions.
(235) thunder, a crate for creating simple command-line programs.
(234) askama, a Jinja-like type-safe compiled templating engine.
(233) semverver, a currently nightly-only cargo subcommand to detect semver violations.
(232) imgref, a trivial Rust struct for interchange of pixel buffers with width, height and stride.
(231) human-panic, a crate to make Rust's error handling usable to end users.
(230) rain, a framework for large-scale distributed computations.
(229) shiplift, a rusty API for talking with docker daemons
(228) ditto, CRDTs for common data structures like maps, vecs, sets, text, and JSON.
(227) fui, a crate to add both a command-line interface and text forms to your program.
(226) noisy_float, a crate with surprisingly useful floating point types that would rather panic than be Not a Number.
(225) cursive, a library for easy text-user interface applications.
(224) trace, a crate to allow for quick debug outputs without println!.
(223) fselect, a crate to find files by SQL-like queries.
(222) afl.rs, a by now pretty well-known fuzzing tool for Rust.
(220) datafusion, a query planner/execution framework for Big Data processing.
(219) rust-semverver, an as-of-yet buggy, but already useful semantic versioning (semver) checking tool.
(218) actix-web, a small fast pragmatic open-source Rust web framework.
(217) cargo-bloat, a cargo subcommand to find out how much space crates/functions take up in an executable.
(216) artifact, a design documentation tool.
(215) YEW, a framework for making Elm/React/Angular-like client web-apps with Rust.

2017

(214) crossbeam-channel, a crate that improves multi-producer multi-consumer channels compared to what the standard library offers.
(213) cargo-audit, a cargo subcommand to look through a crates dependencies for known insecure versions.
(212) printpdf, a pure Rust PDF-writing library that already has a lot of features (though I note a lot of bool-taking methods).
(210) faster, a crate for zero-overhead, cross-platform, beautiful explicit SIMD code.
(209) ammonia, a crate for sanitizing HTML to prevent cross-site scripting (XSS), layout breaking and clickjacking.
(208) failure, a crate to deal with... you guessed it, failure.
(207) futures-await, a crate to simplify writing futures-based async code.
(206) cargo-outdate, a cargo subcommand that shows outdated dependencies including latest compatible and latest version.
(205) colored, a UNIX-based terminal color crate.
(204) if_chain, a macro that helps combat rightwards drift where code nests many ifs and if lets. Since the latter cannot be contracted with &&, this can be really helpful to make code more readable.
(203) abrute, a crate to brute-force AES keys.
(201) rustbreak, a crate providing simple single-file storage to e.g. persist settings.
(200) rug, a crate providing arbitrary-precision integers, rationals and floating-point numbers, using GMP, MPFR and MPC.
(199) pikkr, a JSON parser that can extract values without tokenization and is blazingly fast using AVX2 instructions.
(198) brain, a programming language transpiler to brainfuck of all things.
(196) pest, a PEG-based parsing library.
(195) exa, a modern ls replacement (with a tree thrown in as well) written in Rust.
(194) aesni, a crate providing a Rust AES (Rijndael) block ciphers implementation using AES-NI.
(193) tarpaulin, a crate to collect test coverage of your Rust code.
(192) cute, a crate containing a macro to allow Python (or Haskell) style comprehensions (e.g. c![x / 2, for x in 0..10, if (x & 1) == 0]).
(191) extfsm, a crate to help build finite state machines.
(189) cargo-make, a crate that helps you automate your build workflow beyond what cargo already offers.
(188) strum, a crate that allows you to derive stringify and parse operations for your enums.
(187) include_dir, a crate that lets you include entire directory contents in your binary – like include_str!, but on steroids.
(186) structop, crate that lets your auto-derive your command-line options from a struct to parse them into.
(185) array_tool, a crate with some nice extra functionality for Vecs and Strings.
(182) PX8, a Rust implementation of an Open Source fantasy console.
(181) remove_dir_all, a safe, reliable implementation of remove_dir_all for Windows.
(180) indicatif, a crate to show nice progress bars on the console.
(179) pq, a crate to generically decode protobuf messages.
(177) rust-skeptic, a cargo subcommand to doctest your README.md
(176) fst, contains Finite State Transducers and assorted algorithms that use them (e.g. fuzzy text search).
(175) rust-pretty-assertions, replaces the standard ones to make them shiny.
(173) utest, a testing framework for embedded software.
(172) cargo-fuzz, a cargo subcommand to run libfuzz on your code.
(171) nalgebra, a linear algebra library in and for Rust.
(170) CDRS, a client for Apache Cassandra written completely in Rust.
(169) derive_builder, automatically implement the builder pattern for arbitrary structs. Now with macro 1.1 support (custom derive since Rust 1.15).
(168) djangohashers, a Rust port of Django's password primitives.
(167) tantivy, a full text search engine, akin to Lucene.
(165) alacritty, an OpenGL-propelled Terminal application. Really fast, nice looking. Missing scrollback.
(164) trust, a Travis CI and AppVeyor template to test your Rust crate on 5 architectures and publish binary releases of it for Linux, macOS and Windows.
(163) rocket, an experimental web framework (will need a nightly Rust!) with a focus on ease-of-use, expressability and speed.

2016

(162) raster, an image processing library.
(161) ruru, a wrapper around Ruby's C-API.
(159) seahash, a statistically well-tested fast hash.
(157) cargo-benchcmp, generates nice before-after summaries for benchmarks.
(154) app_dirs, lets you put your app's data in the right place on every platform.
(152) xargo, for effortless cross compilation of Rust programs to custom bare-metal targets like ARM Cortex-M.
(149) ripgrep, a grep/ag/pt/whatever search tool you use replacement that absolutely smokes the competition in most performance tests.
(148) mysql-proxy, a flexible, lightweight and scalable proxy for MySQL databases.
(147) tokio, a high-level asynchronous IO library based on futures.
(146) accurate, a way to do accurate floating point sums.
(145) ring, a crypto implementation.
(143) font-rs, yet another pure Rust font renderer, which is incomplete, but very fast.
(142) rusttype, a pure Rust freetype replacement.
(141) lru_time_cache, a simple but complete least-recently-used cache implementation.
(140) trace, a syntax extension to insert print! statements to functions to help trace execution.
(139) cargo-modules, gives us the cargo modules subcommand that shows the module structure of our crates in a tree view, optionally warning of orphans.
(137) reustmann, a Von-Neumann Architecture written in Rust. This is presumably useful as a base substrate to train genetic algorithms on.
(136) bins, let's us programmatically create pastebins.
(135) error-chain, feels like the missing piece in Rust's Result-based error-handling puzzle.
(134) petgraph, provides graph structures and algorithms.
(133) pbr, gives us a simple way to set up a progress bar for our applications.
(131) parking-lot, gives us synchronization primitives (Mutex, RWLock, CondVar and friends) that are both smaller and faster than the standard library's implementations.
(130) cargo-profiler, lets us profile our code directly from cargo using a variety of tools, notably valgrind's callgrind and cachegrind.
(129) semantic-rs, lets us update our project from the commandline ensuring semver compliance on the way.
(128) arrayvec, gives us a Vec-like interface over plain arrays for those instances where you don't want the indirection.
(127) owning_ref, contains a reference type that can carry its owner with it.
(126) gcc, a crate to easily use the local C compiler, which makes FFI with a build script a breeze.
(125) rustful, a simple, modular REST-like HTTP framework.
(124) gfx, a crate to show stuff on a screen on most available platforms that have one.
(123) tempfile, a crate that does exactly what it says on the tin.
(122) LALRPOP, a LR(1) parser generator that compiles to Rust code.
(121) preferences, which does the right thing to your program's preferences on all common operating systems.
(120) rotor, a mio-based async-IO library providing an event loop, state machine combinators and futures.
(119) diesel, a rustic typesafe extensible object-relational mapper and query builder.
(118) rayon, gives us par_iter()/par_iter_mut() functions that use an internal thread pool to easily parallelize data-parallel operations. There's also rayon::join(|| .., || ..) for Fork-Join-style tasks. Apart from the ease of use, it also performs very well, comparable to hand-optimized code.
(117) roaring, the Rust version of Prof. D. Lemire's compressed bitmap data structure.
(116) herbie-lint, a miraculous compiler plugin to check the numerical stability of floating-point operations in the code.
(115) racer, powers code completion in all Rust development environments.
(114) toml, for all our configuration needs, simple yet effective.
(113) crossbeam, a library of non-blocking data structures and synchronization primitives that makes writing concurrent programs easier and more efficient (both in terms of code and runtime).
(112) rustfmt, because it's nice to Rust with style.

2015

(111) handlebars-rust, an implementation of the Handlebars templating language for Rust. It also allows custom helpers and template inheritance for real-world usage.
(110) clippy, a collection of lints for better Rust code.
(109) quick-error, a rust-macro which makes errors easy to write.
(108) cargo-count, a neat way to summarize line counts for cargo projects.
(107) chrono, a crate that offers very handy timezone-aware Duration and Date/Time types.
(106) nom, a library of fast zero-copy parser combinators, which has already been used to create safe, high-performance parsers for a number of formats both binary and textual.
(105) hyper, offers a Rust HTTP(S) implementation for both clients and servers.
(104) ramp, Ramp supplies some high performance low memory easy to use big integral types. Whenever you need integers too large for a u64 and cannot afford to lose precision, ramp has just what you need.
(103) alias. alias allows mutably aliasing values – which seems to actually be safe, somewhat surprisingly.
(102) winapi-rs
(101) glium, a safe Rust wrapper for OpenGL.
(100) conrod, a simple to use immediate-mode GUI library written in pure Rust.
(99) itertools
(98) quickcheck
(97) lazy_static

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

crates_of_the_week.md

crates_of_the_week.md

Rust crates of the week

2024

Files

crates_of_the_week.md

Latest commit

History

crates_of_the_week.md

File metadata and controls

Rust crates of the week

2024