Format/Blog
- A Daft proc-macro trick: How to Emit Partial-Code + Errors: A recent Oxide and Friends podcast episode, “A crate is born,” detailed the creation of a proc macro for deriving “diffable” data structures with a trick I w...
- Bridging the Efficiency Gap Between FromStr and String | Armin Ronacher's Thoughts and Writings: A trick to convert arbitrary values from owned strings.
- A 10x faster batch job by batching PostgreSQL inserts/updates with Rust and SQLx: I have this hourly batch job that was taking ~30 minutes to complete and was causing too much strain on the database because it needs to insert/update between 300,000 and 500,000 records every time. The batch job makes thousands and thousands of network requests, so a 30 minute execution time
- Vendoring C/C++ dependencies in Rust: What is vendoring about? I'm writing this post because basically I haven't found any guide about this, and for sure with this level of completeness and…
- Transition Systems in Rust: Learn how to define and implement state transitions using Rust, creating robust and maintainable transition systems.
- Translating bzip2 with c2rust - Trifecta Tech Foundation:
- A Gentle Introduction to WebAssembly in Rust (2025 Edition) - DEV Community:
- The power of interning: making a time series database 2000x smaller in Rust | Blog | Guillaume Endignoux: This week-end project started by browsing the open-data repository of Paris’ public transport network, which contains various APIs to query real-time departu...
- Using pgVector with SeaORM in Rust | Data Engineering ∪ Data Science: Use MLflow to productionize an MXNet model in Amazon SageMaker.
- Emjay - a simple JIT that does math · Andrea Bergia's Website: Today I wanna show off my most recent little project, called emjay. It’s a very simple “language”, with an evaluator that generates JIT code and executes it. It does not have a “normal” interpreter, only the JIT compiler. The language is extremely limited, but that was intentional, since I wanted something simple that I could write end-to-end. All the code is written in Rust and it is hosted on GitHub at https://github.com/andreabergia/emjay. It’s roughly 4k lines of code including tests, so it is small enough to be presented in this post.
- ioctls from Rust - by Julio Merino - Blog System/5: Diving into what the ioctl system call is and how to invoke it from Rust
- From hours to 360ms: over-engineering a puzzle solution | Blog - Daniel Huang: where my words occasionally escape /dev/null
- A length-indexed Vector in Rust: Sneak peeking at Dependent Types and an encoding of length-indexed vectors in Rust to constraint consumers on operations they can perform. It’s customary to introduce Dependent Types (types as first-class citizens that may depend on terms) with vectors (or rather linked-lists) parameterized by a type A, indexed by a type...
- Mix in Rust with Java (or Kotlin!):
- Writing a Simple Driver in Rust – Pavel Yosifovich: The Rust language ecosystem is growing each day, its popularity increasing, and with good reason. It's the only mainstream language that provides memory and concurrency safety at compile time, with a powerful and rich build system (cargo), and a growing number of packages (crates). My daily driver is still C++, as most of my work…
- Provisioning TLS Certificates in Rust With ACME | Shuttle: How we provision TLS certificates for custom domains in Rust using the `instant_acme` crate.
- First Steps in Game Development With Rust and Bevy | The RustRover Blog: Some of us might remember this 15-year-old Abstruse Goose comic about our choices in life. Learning the theory of computations might not be the most direct path to video game development.
- Cooperative multitasking in Rust: Async runtimes and concurrency patterns
- Pinning Down "Future Is Not Send" Errors | Evan Schwartz: If you use async Rust and Tokio, you are likely to run into some variant of the "future is not Send" compiler error. While transitioning some sequential asyn...
- Optimizing with Novel Calendrical Algorithms:
- Apache Kafka protocol with serde, quote, syn and proc_macro2: Using serde, quote, syn and proc_macro2 to implement the Kafka protocol in Rust.
- Tips for Faster Rust CI Builds | corrode Rust Consulting: I’ve been working with many clients lately who host their Rust projects on GitHub...
- How to write DRY code in Rust - Art’s Substack: Rust Best Practices: Avoiding Repetition with Advanced Code Structuring
- Streaming Audio Apis: The Axum Server | xd009642:
- Prototyping in Rust | corrode Rust Consulting: Programming is an iterative process - as much as we would like to come up with the perfect solution from the start, it rarely works that way.
- Concurrent and parallel future execution in Rust: A lot has been written about concurrency and parallelism, so we only briefly define what is needed for this article: Concurrent programming allows us to run two or more computations in overlapping per
- Adding A New Fake To The Fake Crate | xd009642: This post is going to go through my process of PRing something to the fake crate.
- Compile-time Hex String Validation in Rust using Const Evaluation - Move into the Future: Learn how to leverage Rust's const evaluation features to validate hex strings at compile time, ensuring type safety and zero runtime overhead.
- Creating an embedded device driver in Rust | voided warranty: In this post, we take a look at developing a device driver in Rust using Dion Dokter’s device driver crate
- Demystifying Alignment and Memory Layout in Rust: Building blocks for performant, efficient and correct applications
- Basics of Pinning in Rust: How pinning memory makes for a sound application
- A Complete Guide to WASIp2 for Rust and Python Programmers | Ideas Reifying:
- Fast Unorm Conversions - RunDev: Optimizing the conversion of 5-bit unorms to 8-bit unorms in Rust.
- Master Hexagonal Architecture in Rust: Everything you need to write flexible, future-proof Rust applications using hexagonal architecture.
- The Definitive Guide to Error Handling in Rust: Learn to model and handle any error using idomatic Rust.
- How to build and publish multi-platform Rust binaries via Github actions | exotext: How to build and publish multi-platform Rust binaries via Github actions | exotext
- orxfun - notes: This article discusses iterable and collection traits that represent types that can be iterated over repeatedly, and how they are introduced almost effortlessly thanks to the powerful type system of rust.
- Read the Code: Using Drop Safely in Rust — Sympolymathesy, by Chris Krycho: A deep dive into Rust’s vec::Drain and its Drop implementation as an example of how ownership prevents subtle bugs—memory and otherwise!
- Caio's Stuff:
- rustunit: Rustunit offers software development consulting with a focus on rust, game-development and large scale distributed backend services.
- Parsing MIDI messages in Rust | nicole@web:
- Designing a const `array::from_fn` in stable Rust:
- Developing a Zellij plugin using Rust: A walkthrough of creating a Zellij plugin from start to end
- Justin Beaurivage's Blog: Version 0.20.0 of the atsamd-hal project was recently released. With it comes its first official support for async peripheral APIs. To mark the occasion, I wanted to share my experience writing futures from scratch on microcontrollers, and help demistify this sometimes complex, yet incredibly useful tool.
- Rust 🦀 on the RP2040: Get stated with writing rust on the Raspberry Pico
-
Build with Naz : TLS (Transport Layer Security) in Rust with tokio, rustls, CFSSL - YouTube:
This video shows how you can use TLS, Rust, and CFSSL to:- create self signed certificate and certificate authority, and keys- create server certificate issu...
-
Article version
- Securely sending DHT22 sensor data from an ESP32 board to PostgreSQL | Caio's Stuff: Let's collect data provided by a DHT22 sensor and store it asynchronously in a PostgreSQL database via WiFi using an encrypted connection. We will start with a brief introduction about the principal technologies, proceed to setting-up the necessary environment and then code our project.
- Building Thread-safe Async Primitives in 150 lines of Rust | Amit's Blog: In this post, I’ll go over a simple, yet fast implementation of the (commonly seen) “oneshot” channel, going through lower-level asynchronous Rust, synchronization primitives, all alongside the unseen footguns of concurrent code
- Writing a mark-and-sweep tracing GC in Rust: Mark-and-sweep garbage collection of unreachable objects
- Exploring Async Runtimes by Building our Own :: KataShift: Who needs tokio?
- orxfun - notes: This article discusses the requirement for vector traits and motivation behind the orx-v crate that provides discussed abstraction to unify the vectors.
-
Rope Optimizations, Part 1 — Zed's Blog:
From the Zed Blog: In this episode of Zed Decoded, Thorsten and Antonio walk through the performance optimizations Antonio when working on Zed's Rope data structure before they then pair on adding more optimizations
-
Video version
- Building a Wifi-controlled car with Rust and ESP32: A technical blog about Rust, Linux and other topics.
- Building an email address parser in Rust with nom: Using Nom to create a safe email validation parser in Rust. How to create combinator parsing that can be compiled to WebAssembly.
- dtype_dispatch: a most beautiful hack - Graph All The Things: dtype_dispatch: a most beautiful hack - Graph All The Things, a math blog by Martin Loncaric
- rustunit: Rustunit offers software development consulting with a focus on rust, game-development and large scale distributed backend services.
-
Build with Naz : Diesel ORM, SQLite, and Rust - YouTube:
Build with Naz : Diesel ORM, SQLite, and RustThis video shows how you can use Rust and Diesel ORM to:- create and run migrations- generate schemas- perform C...
-
Article version
-
README.md · main · Cyril Marpaud / Impl Snake for Microbit · GitLab:
Rust implementation of a Snake game on BBC Micro:bit with Embassy.
-
[French] Video version
- Rust Syn Crate Tutorial: Automate Builder Patterns with Custom Macros: Learn how to use the Rust Syn crate to create custom builder patterns with procedural macros. This tutorial covers step-by-step implementation, examples, and tips for building flexible APIs in Rust with Syn.
- Parsing arguments in Rust with no dependencies | nicole@web:
- Why I love Rust for tokenising and parsing | xnacly - blog: Macros, iterators, patterns, error handling and match make Rust almost perfect
- "German string" optimizations in Spellbook:
- Rust's Most Subtle Syntax | zk: 'What?' - Richard Nixon
- Jens Getreu's blog - How to shallow clone a Cow:
- Rust's Sneaky Deadlock With `if let` Blocks | Brooks Blog: Rust is my favorite programming language. I've been writing Rust for about 6 years, from college to professionally, and I'm vocal about how helpful the compi...
- Difference Between iter() and into_iter() in Rust - crustc: 1. Introduction The Rust language provides iterators that make complex data structures easy to traverse, transform, and filter. Common iterators in Rust include iter(), iter_mut(), and into_iter(). Iter() and into_iter() are provided for different use cases. In this tutorial, we'll learn the basics of iter() and into_iter(). Finally, we'll see an example use case and
- Integer Compression :: KataShift: Why use many byte when few byte do trick?
- Simple way to make i18n support in Rust with with examples and tests - OnlyCoiners: Localization is crucial for modern software development. By supporting multiple languages, applications can reach a wider audience and become more inclusive, al...
- rust-blog/posts/rust-in-non-rust-servers.md at master · pretzelhammer/rust-blog · GitHub: Educational blog posts for Rust beginners. Contribute to pretzelhammer/rust-blog development by creating an account on GitHub.
- Reading a Remote File Using Rust - crustc: 1. Introduction Remote servers are essential in modern computing and are used by many institutions from small businesses to enterprises. SSH (Secure Shell) is a protocol that allows secure remote access to systems. By using SSH, we can interact with files on a remote server without downloading them locally. In this tutorial, we'll explore how
- When should I use String vs &str?:
- Rust Async I/O: Futures, Thread Pools: Learn how Rust's async system enhances performance by utilizing futures, wakers, and thread pools for non-blocking I/O operations
- orxfun - notes: Web site created using create-react-app
- Rust interop in practice: speaking Python and Javascript - Blog - Tweede golf:
- A small trick for simple Rust/C++ interop:
- Understanding Memory Ordering in Rust | Evan Schwartz: I am reading Mara Bos' Rust Atomics and Locks. On the first pass, I didn't really grok memory ordering. So here's my attempt at understanding by explaining.
-
Build with Naz : Rust Lifetimes - YouTube:
This video, related article and repo explore Rust lifetimes using lots of examples (seven)
-
Article version
-
Build with Naz : Rust subtyping and variance - YouTube:
This video, related article and repo explore Rust subtyping and variance. They are related to the Rust lifetime video.Article:
-
Article version
- Mix in Rust with Python: PyO3:
- Building a Bevy Plugin for Rolling Dice // Erik Horton: I’ve been thinking through a game idea that I know will need a dice rolling mechanic, so I decided to build out an MVP of that. The following is the end result of 2 days of working through that.
- Packaging a Rust Program for Fedora | Jose Fernandez: Packaging a Rust program for Fedora may seem daunting initially, but it’s more straightforward than expected, thanks to excellent documentation, Rust-specific tooling, and a helpful community. Over the past two months, I packaged bpftop, a process monitor for eBPF programs. While there were some specific considerations with Rust, the process was manageable. In this post, I’ll share the steps I took, the insights I gained, and how to streamline the experience.
-
Build with Naz : Explore Linux TTY, process, signals w/ Rust - Part 1/3 (background info) - YouTube:
This video series, related article and repo explore Linux TTY, processes, signals, and more using Rust. The video provides live coding examples of using Rust...
-
Build with Naz : Explore Linux TTY, process, signals w/ Rust - Part 2/3, live code signal, proc, IPC
-
Build with Naz : Explore Linux TTY, process, signals w/ Rust - Part 3/3 (tokio::process::Command)
-
Article version
- GraphQL based Admin Dashboard with Loco and Seaography | SeaQL: In this tutorial, we would develop a GraphQL based admin dashboard with Seaography and Loco.
- tracing tokio resources - hēg denu - Hayden Stainsby:
- Sqlx4k - Interoperability between Kotlin and Rust, using FFI (Part 1) | :: exploration and stuff ::: Introduction Previously, in the Sqlx4k - Introduction to Kotlin Native and FFI (Part 2), the second part of this series, we attempted to provide an introduction to how C Interoperability functions in Kotlin, offering various examples from the GitHub - smyrgeorge/sqlx4k codebase. Sqlx4k is a small, non-blocking PostgreSQL database driver written in Kotlin for the Native platform. It wraps the sqlx driver from the Rust ecosystem under the hood. The communication between the two languages is facilitated using FFI.
- Crafting Interpreters with Rust: On Garbage Collection | ltungv: I became interested in implementing programming languages a few years ago and discovered [Crafting Interpreters](https://craftinginterpreters.com/) by Bob Nystrom. At the time, I had experience with Rust and decided to use it to follow the book. Albeit, being a noob, I managed to implement a fully functional bytecode interpreter that supported every feature of the Lox language as described. However, my implementation suffered memory leaks due to reference counting. Back then, I didn't fully grasp Rust to design and implement a proper garbage collector (GC)! Now that I have more confidence in the language, I decided to revisit the project and improve its memory management scheme.
-
Build with Naz : Box and Pin exploration in Rust | developerlife.com:
This tutorial, video, and repo are a deep dive into Rust Pin and Box types, along with concepts of ownership and borrowing. We will also cover a lot of background information on the concepts of operating system process, memory allocation and access, stack, and heap. The examples we create are designed to demonstrate the different semantics around the use of boxes and pinned boxes in Rust.
-
Video version
- Global Registration: You might not have considered this before, but tests in Rust are rather magical. Anywhere in your project you can slap `#[test]` on a function and the compiler makes sure that they're all automatically run. This pattern, of wanting access to items that are distributed over a crate and possibly even multiple crates, is something that projects like bevy, tracing, and dioxus have all expressed interest in but it's not something that Rust supports except for tests specifically.
- How to organize large Rust codebases: Want to learn more real-world Rust, offensive security and applied cryptography? Take a look at my book Black Hat Rust, where, among other things, you will learn how to build your own end-to-end encryption protocol for a Remote Access Tool (RAT), web servers and exploits in Rust. As a Rust
- Surprises with Rust's `as` (and Python division) | Anna Hope: `as` is easy, convenient, and maybe not something to use
- Writing eBPF Tracepoint Program with Rust Aya: Tips and Example – Yuki Nakamura's Blog: TL;DR This post shows an example eBPF Tracepoint program and shares tips on writing the eBPF Tracepoint programs with aya. 🦀🐝 IntroductionDataflow Kernel spaceUser spaceBenefits of using ayaOne language: RustAuto-generating Rust codesRun eBPF Tracepoint tracing programPrerequisitesCloneGenerate structs codesBuild and RunTips on writing eBPF codesTip1: Deserializing with generated struct codesTip2. Decode __data_locTip3. PerCpuArray eBPF Map as…
- How to make Rust Desktop App with Egui and ChatGPT - OnlyCoiners: In this post, you will learn how to make a desktop app with Rust Eguiand ChatGPT with the async-openai-rustpackage. You can ...
- Mix in C with Rust: A taste of C in your Rust:
- Mix in Rust with C: Delegating FFI definitions to Diplomat:
- Mix in Rust:
- Fastest Vec Update on My Computer | Anti Object Oriented Programming: “Premature optimization is the root of all evil.” At least that is what ‘big java’ wants you to think. But if I wasn’t worried about optimizations I’d be using linked lists in Haskell. I use rust because I want speed. If you are here for speed, then keep reading. In this post you’ll find a detailed account of how I created a problem, solved the problem, and then optimized the solution way to much.
- Async Rust for Dummies: Introduction Hello, Rustaceans! I'm quite sure many of you use async Rust every day in your projects, but do you actually know how it works under the hood? In…
- Write Cleaner, More Maintainable Rust Code with PhantomData: Solving the Redundancy Problem: How PhantomData Saves the Day in Rust
- Getting better insights into your Rust applications - 21 Lessons: Use the tracing crate to make your first step towards Observability
- How to instrument a Rust application with OpenTelemetry - 21 Lessons: Collect runtime inFormation from your Rust application with OpenTelemetry
- An Intro to the Rust Programming Language: Getting introduced to the Rust programming language and why you should try it.
- Deserializing Binary Data Files in Rust · Michael-F-Bryan:
- Zig Makes Rust Cross-compilation Just Work | Actually.fyi: Cross-compiling to ARM MacOS with Zig is Easy.
- Fast and Simple Rust Interner: This post describes a simple technique for writing interners in Rust which I haven't seen documented before.