Topic

#Topic/ABA

- Solving the ABA Problem in Rust with Tagged Pointers: Solving the ABA Problem in Rust: Tagged Pointers with Versioning
- Epoch Adventures: Breaking Free from ABA in Concurrent Rust

#Topic/ACME

- Provisioning TLS Certificates in Rust With ACME | Shuttle: How we provision TLS certificates for custom domains in Rust using the `instant_acme` crate.

#Topic/AdventOfCode

- Solving Advent of Code at Compile Time with Rust Macros | Double Free Dev: Producing good software is difficult. Writing tests, reasoning about unintended effects, tedious considerations about time vs memory trade-offs. The perfe...

#Topic/Algirthm

- Introduction - Gray-Scott with Rust:

#Topic/Algorithm

- Optimizing with Novel Calendrical Algorithms:

#Topic/Architecture

- Master Hexagonal Architecture in Rust: Everything you need to write flexible, future-proof Rust applications using hexagonal architecture.

#Topic/Async

- 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...

- 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

- Introduction - Hello async Rust:

- Caio's Stuff:

- 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.

- 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

- Exploring Async Runtimes by Building our Own :: KataShift: Who needs tokio?

- Async Rust in Three Parts:
- Async Rust, Part One: Futures
- Async Rust, Part Two: Tasks
- Async Rust, Part Three: IO

- 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

- Build with Naz : Create an async shell in Rust - YouTube: This video shows how you can build an async REPL or shell in Rust, using the r3bl_terminal_async crate. This example simply creates a long running bash proce...

- Mastering Dependency Injection in Rust: Crafting a Custom Container - chesedo: Learn how to implement a custom Dependency Injection (DI) container in Rust. This comprehensive guide covers various dependency types, lifetimes, and advanced patterns, providing a solid foundation for building modular and testable Rust applications.
- Mastering Dependency Injection in Rust: Despatma basics
- Mastering Dependency Injection in Rust: Despatma with Lifetimes

- tracing tokio resources - hēg denu - Hayden Stainsby:

- 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…

#Topic/Audio

- Rust in Audio - YouTube: In this video, I'll show you all the basic types of collections that are relevant for audio and how to pass them as references to functions.The Rust in Audio...
- Rust in Audio: Collections
- Rust in Audio: Pointers & Lifetimes
- Rust in Audio: Interleaved Audio & Iterators
- Rust in Audio: Generics & Traits

#Topic/Bevy

- 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.

- rustunit: Rustunit offers software development consulting with a focus on rust, game-development and large scale distributed backend services.

#Topic/BevyPlugin

- 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.

#Topic/Box

- 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

#Topic/Build

- 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

#Topic/C2Rust

- Translating bzip2 with c2rust - Trifecta Tech Foundation:

#Topic/CI

- Tips for Faster Rust CI Builds | corrode Rust Consulting: I’ve been working with many clients lately who host their Rust projects on GitHub...

#Topic/CI/GitHub

- 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 build and publish multi-platform Rust binaries via Github actions | exotext: How to build and publish multi-platform Rust binaries via Github actions | exotext

#Topic/CStruct

- Deserializing Binary Data Files in Rust · Michael-F-Bryan:

#Topic/Calendering

- Optimizing with Novel Calendrical Algorithms:

#Topic/CodeOrganisation

- 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

#Topic/Collections

- Rust Collections Explained - YouTube: A rundown of Rust collections and iterators, including a bit about what's going on behind the scenes.

#Topic/Compiler

- 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.

- 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...

- Part 0: Designing a Language without a Parser · Thunderseethe's Devlog: Designing a language, types first
- Part 1: Bidirectional Constraint Generation
- Part 2: Tying up Type Inference
- Part 3: Rowing Afloat Datatype Boats
- Part 4: TypeChecking Top Level Functions
- Part 5a: Lowering Our AST to Escape the Typechecker
- Part 5b: Escaping the Typechecker, an Implementation
- Part 6a: Lowering Row Types, Evidently
- Part 6b: The Types of Lowered Rows
- Part 6c: The Heart of Lowered Rows
- Part 7: Lowering Top Level Items

#Topic/Compression

- Integer Compression :: KataShift: Why use many byte when few byte do trick?

#Topic/Const

- 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.

- Designing a const `array::from_fn` in stable Rust:

#Topic/CopyOnWrite

- Jens Getreu's blog - How to shallow clone a Cow:

#Topic/CorssCompile

- Zig Makes Rust Cross-compilation Just Work | Actually.fyi: Cross-compiling to ARM MacOS with Zig is Easy.

#Topic/CrossPlatform

- Ferrostar: Building a Cross-Platform Navigation SDK in Rust (Part 1) | Stadia Maps: The first in a series of technical blog posts covering cross-platform mobile development in Rust.
- Ferrostar: Building a Cross-Platform Navigation SDK in Rust (Part 2 - iOS Packaging)

#Topic/DNS

- Building a DNS Server in Rust: Part 1 of 2: Learn how to build a DNS server in Rust from scratch. Explore the DNS protocol, create a simple server, and handle DNS queries with ease.

#Topic/DataCompression

- Translating bzip2 with c2rust - Trifecta Tech Foundation:

#Topic/Deadlock

- 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...

#Topic/DependancyInjection

- Mastering Dependency Injection in Rust: Crafting a Custom Container - chesedo: Learn how to implement a custom Dependency Injection (DI) container in Rust. This comprehensive guide covers various dependency types, lifetimes, and advanced patterns, providing a solid foundation for building modular and testable Rust applications.
- Mastering Dependency Injection in Rust: Despatma basics
- Mastering Dependency Injection in Rust: Despatma with Lifetimes

#Topic/Driver

- 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…

- 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

#Topic/Drop

- 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!

#Topic/ESP32Cam

- Building a Wifi-controlled car with Rust and ESP32: A technical blog about Rust, Linux and other topics.

#Topic/Embedded

- Rust and embedded programming with Leon Vak: In this online session Leon Vak, who gave 3 excellent presentations about Embedded programming and Linux kernel programming with Rust at Abra, is going to show us how he uses Rust to write programs for an embedded device.

- Nine Pico PIO Wats with Rust (Part 1) | Towards Data Science: Raspberry Pi programmable IO pitfalls illustrated with a musical example
- Nine Pico PIO Wats with Rust (Part 2)

- Intro to Embassy : embedded development with async Rust - YouTube: In this one we investigate some of the crates within the Embassy framework.Subscribe : https://www.youtube.com/@therustybits?sub_confirmation=1Patreon : http...

- 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

- Beginner Rust ESP32 development - Snake: A technical blog about Rust, Linux and other topics.

#Topic/ErrorHandling

- The Definitive Guide to Error Handling in Rust: Learn to model and handle any error using idomatic Rust.

#Topic/FFI

- 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.

- Sqlx4k - Introduction to the Kotlin native and FFI (Part 1) | :: exploration and stuff ::: Introduction Recently, I began experimenting with the Kotlin Native platform. I initiated a new repository and attempted to create a simple project utilizing the ktor libraries. The purpose of the project was to recreate a small service that integrates some basic libraries and compile it to a native target (macosArm64 in my case). The service aimed to offer support for: Dependency injection HTTP server Database access (PostgreSQL) Additionally, RabbitMQ support (though it isn’t a priority for now) In this first article of the series, I aim to describe how I ended up writing “low-level” code (FFI between Kotlin and Rust) and also to highlight the importance of native compatibility in Kotlin Native.
- Sqlx4k - Introduction to the Kotlin native and FFI (Part 2)

#Topic/FromScratch

- Parsing arguments in Rust with no dependencies | nicole@web:

- Tutorial: Implementing JSON parsing (Rust) | David's Software: Learn the fundamentals of parsing by implementing JSON parsing from scratch
- Tutorial: Writing a JSON Parser (Rust) - Part 2/2

#Topic/Futex

- Futexes at Home:

#Topic/GarbageCollection

- Writing a mark-and-sweep tracing GC in Rust: Mark-and-sweep garbage collection of unreachable objects

- 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.

#Topic/GettingStarted

- Rust 🦀 on the RP2040: Get stated with writing rust on the Raspberry Pico

#Topic/GlobalRegistration

- 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.

#Topic/Gotchas

- Surprises with Rust's `as` (and Python division) | Anna Hope: `as` is easy, convenient, and maybe not something to use

#Topic/GraphQL

- GraphQL based Admin Dashboard with Loco and Seaography | SeaQL: In this tutorial, we would develop a GraphQL based admin dashboard with Seaography and Loco.

#Topic/HTTPServer

- Backend In Rust - 01 Building a basic server - YouTube: Welcome to the first episode of our "Backend in Rust" series! In this video, we'll walk you through the basics of building a simple HTTP server using Rust. W...
- Backend in Rust 02 - JWT Authentication, Sea ORM, Axum, Rust

#Topic/HexStrings

- 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.

#Topic/HighPerformanceComputing

- Introduction - Gray-Scott with Rust:

#Topic/IfLetBlock

- 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...

#Topic/Interpreter

- Crafting an Interpreter in Rust #01: Basic Bytecode Chunks - PeerTube (xy-space): In this video, we start our journey on implementing a bytecode virtual machine for the Lox language by implementing a data structure for our bytecode: a chunk. This series follows the second part o...
- Crafting an Interpreter in Rust #02: First Virtual Machine
- Crafting an Interpreter in Rust #03: Scanning on Demand

- Implementing a Lox interpreter in Rust - YouTube: For some time I've been looking for an opportunity to do a stream on writing a parser + interpreter for... something. Anything really. I've wanted to impleme...

#Topic/Intro

- An Intro to the Rust Programming Language: Getting introduced to the Rust programming language and why you should try it.

#Topic/Ioctls

- ioctls from Rust - by Julio Merino - Blog System/5: Diving into what the ioctl system call is and how to invoke it from Rust

#Topic/Iterator

- 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.

- 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

#Topic/Iterators

- Rust Collections Explained - YouTube: A rundown of Rust collections and iterators, including a bit about what's going on behind the scenes.

#Topic/JIT

- 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.

- 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...

#Topic/JNI

- Mix in Rust with Java (or Kotlin!):

#Topic/JNR-FFI

- Mix in Rust with Java (or Kotlin!):

#Topic/JSONParsing

- Tutorial: Implementing JSON parsing (Rust) | David's Software: Learn the fundamentals of parsing by implementing JSON parsing from scratch
- Tutorial: Writing a JSON Parser (Rust) - Part 2/2

#Topic/JWT

- Backend In Rust - 01 Building a basic server - YouTube: Welcome to the first episode of our "Backend in Rust" series! In this video, we'll walk you through the basics of building a simple HTTP server using Rust. W...
- Backend in Rust 02 - JWT Authentication, Sea ORM, Axum, Rust

#Topic/Lifetimes

- Build with Naz : Rust Lifetimes - YouTube: This video, related article and repo explore Rust lifetimes using lots of examples (seven)
- Article version

#Topic/Localization

- 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...

#Topic/MIDI

- Parsing MIDI messages in Rust | nicole@web:

#Topic/Macro

- Derive Macros — by Lowell Thoerner — Seattle Rust User Group, December 2024 - YouTube: Or, How I Learned to Stop Worrying and Love the proc_macro2::TokenStreamContact & Code

- Solving Advent of Code at Compile Time with Rust Macros | Double Free Dev: Producing good software is difficult. Writing tests, reasoning about unintended effects, tedious considerations about time vs memory trade-offs. The perfe...

- 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.

- Why I love Rust for tokenising and parsing | xnacly - blog: Macros, iterators, patterns, error handling and match make Rust almost perfect

#Topic/Macro/Procedural

- 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...

- Comprehending Proc Macros - YouTube: Rust procedural macros can do amazing things, including implementing an entire dang Python feature from scratch. I've wanted to make this "lecture+tutorial" ...

#Topic/Mandelbrot

- Beyond multi-core parallelism: faster Mandelbrot with SIMD: Optimizing your code is a valuable addition to multi-core parallelism. In this article, we’ll see an example using SIMD.
- Using portable SIMD in stable Rust

#Topic/MarkAndSweep

- Writing a mark-and-sweep tracing GC in Rust: Mark-and-sweep garbage collection of unreachable objects

#Topic/Memory

- Demystifying Alignment and Memory Layout in Rust: Building blocks for performant, efficient and correct applications

- 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 memory address and size - YouTube: This video shows how you can get the address and size of variables on the stack and heap in Rust.Issue that inspired this video

#Topic/Multi-threading

- Solving the ABA Problem in Rust with Tagged Pointers: Solving the ABA Problem in Rust: Tagged Pointers with Versioning
- Epoch Adventures: Breaking Free from ABA in Concurrent Rust

#Topic/Multiplexer

- Developing a Zellij plugin using Rust: A walkthrough of creating a Zellij plugin from start to end

#Topic/Multitasking

- Cooperative multitasking in Rust: Async runtimes and concurrency patterns

#Topic/Observability

- Getting better insights into your Rust applications - 21 Lessons: Use the tracing crate to make your first step towards Observability

#Topic/OpenTelemetry

- How to instrument a Rust application with OpenTelemetry - 21 Lessons: Collect runtime inFormation from your Rust application with OpenTelemetry

#Topic/Optimisation

- 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

- Optimizing with Novel Calendrical Algorithms:

- Demystifying Alignment and Memory Layout in Rust: Building blocks for performant, efficient and correct applications

- Fast Unorm Conversions - RunDev: Optimizing the conversion of 5-bit unorms to 8-bit unorms in Rust.

- Optimization adventures: making a parallel Rust workload 10x faster with (or without) Rayon | Blog | Guillaume Endignoux: In a previous post, I’ve shown how to use the rayon framework in Rust to automatically parallelize a loop computation across multiple CPU cores.Disappointing...
- Optimization adventures: making a parallel Rust workload even faster with data-oriented design (and other tricks)

- 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

- "German string" optimizations in Spellbook:

- 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.

- Beyond multi-core parallelism: faster Mandelbrot with SIMD: Optimizing your code is a valuable addition to multi-core parallelism. In this article, we’ll see an example using SIMD.
- Using portable SIMD in stable 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.

#Topic/PGVector

- Using pgVector with SeaORM in Rust | Data Engineering ∪ Data Science: Use MLflow to productionize an MXNet model in Amazon SageMaker.

#Topic/PhantomData

- Write Cleaner, More Maintainable Rust Code with PhantomData: Solving the Redundancy Problem: How PhantomData Saves the Day in Rust

#Topic/Pin

- Basics of Pinning in Rust: How pinning memory makes for a sound application

- 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

#Topic/Plotting

- Porting the guff plot device to Rust - YouTube: For this stream, I wanted to implement something in Rust where we didn't _also_ need to learn a new technical topic, and instead could focus just on the "wri...

#Topic/Polymorphism

- Build with Naz : traits, subtyping, polymorphism in Rust - YouTube: This video shows how you can use subtyping and traits in Rust to create polymorphic code that is similar to what you might expect from an OOP language. Rust ...

#Topic/Postgresql

- 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

#Topic/PrattParsing

- Implementing a Lox interpreter in Rust - YouTube: For some time I've been looking for an opportunity to do a stream on writing a parser + interpreter for... something. Anything really. I've wanted to impleme...

#Topic/Prototyping

- 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.

#Topic/RasberryPi

- Rust 🦀 on the RP2040: Get stated with writing rust on the Raspberry Pico

#Topic/RaspberryPicco

- Rust 🦀 on the RP2040: Get stated with writing rust on the Raspberry Pico

#Topic/ReactionDiffusion

- Introduction - Gray-Scott with Rust:

#Topic/Release

- 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

#Topic/SIMD

- From hours to 360ms: over-engineering a puzzle solution | Blog - Daniel Huang: where my words occasionally escape /dev/null

- Beyond multi-core parallelism: faster Mandelbrot with SIMD: Optimizing your code is a valuable addition to multi-core parallelism. In this article, we’ll see an example using SIMD.
- Using portable SIMD in stable Rust

#Topic/SQL

- Build your own SQLite, Part 1: Listing tables: As developers, we use databases all the time. But how do they work? In this series, we'll try to answer that question by building our own SQLite-compatible database from scratch. Source code examples will be provided in Rust, but you are encouraged t...
- Build your own SQLite, Part 2: Scanning large tables
- Build your own SQLite, Part 3: SQL parsing 101
- Build your own SQLite, Part 4: reading tables metadata
- Build your own SQLite, Part 5: Evaluating queries

#Topic/SQLite

- 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

#Topic/ScreenCapture

- Making games play themselves with Rust Part 1: Screen Interaction: An introduction to automated gaming!
- Making games play themselves with Rust Part 2: Parsing the Game State
- Making games play themselves with Rust Part 2.5: Proof by Exhaustive Search

#Topic/SearchEngine

- Hello > Building a search engine from scratch, in Rust: introduction: Have you ever wondered how search engines work under the hood? I'm not talking about vector search or anything fancy, but just the good old search engines that could really find what we would look for…
- Building a search engine from scratch, in Rust: part 1

#Topic/Serde

- Apache Kafka protocol with serde, quote, syn and proc_macro2: Using serde, quote, syn and proc_macro2 to implement the Kafka protocol in Rust.

- Serde Trait - Part 1: Overview | My blog: Serde for trait objects - Part 1: Overview
- Serde for trait objects - Part 2: Serialization
- Serde for trait objects - Part 3: Deserialization

#Topic/ShallowClone

- Jens Getreu's blog - How to shallow clone a Cow:

#Topic/Simulation

- Introduction - Gray-Scott with Rust:

#Topic/StateMachine

- Transition Systems in Rust: Learn how to define and implement state transitions using Rust, creating robust and maintainable transition systems.

#Topic/Strings

- When should I use String vs &str?:

#Topic/Subtyping

- 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

#Topic/Syntax

- Rust's Most Subtle Syntax | zk: 'What?' - Richard Nixon

#Topic/TLS

- Provisioning TLS Certificates in Rust With ACME | Shuttle: How we provision TLS certificates for custom domains in Rust using the `instant_acme` crate.

- 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

#Topic/TLS-certificate

- Provisioning TLS Certificates in Rust With ACME | Shuttle: How we provision TLS certificates for custom domains in Rust using the `instant_acme` crate.

#Topic/TTY

- 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

#Topic/TUI

- Ratatui - terminal user interfaces in Rust with Orhun Parmaksız - build ratatop in pair programming - YouTube:
- Transcript

#Topic/Testing

#Topic/Testing/Fuzzing

- Decrusting the quickcheck crate - YouTube: In this stream, we peeled back the crust on the quickcheck crate —https://github.com/BurntSushi/quickcheck/ — and explored its interface,structure, and mecha...

#Topic/Time

- Optimizing with Novel Calendrical Algorithms:

#Topic/Tokoniser

- Why I love Rust for tokenising and parsing | xnacly - blog: Macros, iterators, patterns, error handling and match make Rust almost perfect

#Topic/Tracing

- tracing tokio resources - hēg denu - Hayden Stainsby:

#Topic/TypeCasting

- Surprises with Rust's `as` (and Python division) | Anna Hope: `as` is easy, convenient, and maybe not something to use

#Topic/TypeInterface

- Part 0: Designing a Language without a Parser · Thunderseethe's Devlog: Designing a language, types first
- Part 1: Bidirectional Constraint Generation
- Part 2: Tying up Type Inference
- Part 3: Rowing Afloat Datatype Boats
- Part 4: TypeChecking Top Level Functions
- Part 5a: Lowering Our AST to Escape the Typechecker
- Part 5b: Escaping the Typechecker, an Implementation
- Part 6a: Lowering Row Types, Evidently
- Part 6b: The Types of Lowered Rows
- Part 6c: The Heart of Lowered Rows
- Part 7: Lowering Top Level Items

#Topic/Unix

- ioctls from Rust - by Julio Merino - Blog System/5: Diving into what the ioctl system call is and how to invoke it from Rust

#Topic/Unorm

- Fast Unorm Conversions - RunDev: Optimizing the conversion of 5-bit unorms to 8-bit unorms in Rust.

#Topic/Unsafe

- Deserializing Binary Data Files in Rust · Michael-F-Bryan:

#Topic/Validation

- 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.

#Topic/VectorSearch

- Using pgVector with SeaORM in Rust | Data Engineering ∪ Data Science: Use MLflow to productionize an MXNet model in Amazon SageMaker.

#Topic/VectorTraits

- 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.

#Topic/Vendoring

- 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…

#Topic/WASIp2

- A Complete Guide to WASIp2 for Rust and Python Programmers | Ideas Reifying:

#Topic/WASM

- A Complete Guide to WASIp2 for Rust and Python Programmers | Ideas Reifying:

#Topic/Wasm

- rustunit: Rustunit offers software development consulting with a focus on rust, game-development and large scale distributed backend services.

#Topic/WasmBindgen

- Introduction - The `wasm-bindgen` Guide:

- Rust interop in practice: speaking Python and Javascript - Blog - Tweede golf:

#Topic/Web

- Caio's Stuff:

#Topic/Webassembly

- Hello > Building a search engine from scratch, in Rust: introduction: Have you ever wondered how search engines work under the hood? I'm not talking about vector search or anything fancy, but just the good old search engines that could really find what we would look for…
- Building a search engine from scratch, in Rust: part 1

- A Gentle Introduction to WebAssembly in Rust (2025 Edition) - DEV Community:

- Introduction - Rust and WebAssembly:

- Introduction - The `wasm-bindgen` Guide:

- How to run WebAssembly from your Rust Program - 21 Lessons: Learn how you can embed WebAssembly in your Rust program with wasmtime

#Topic/Websocket

- Streaming Audio Apis: The Axum Server | xd009642:

#Topic/ZellijPlugin

- Developing a Zellij plugin using Rust: A walkthrough of creating a Zellij plugin from start to end

#Topic/eBPF

- 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…

#Topic/parsingCLIArguments

- Parsing arguments in Rust with no dependencies | nicole@web: