Type-Safe & High-Perf Distributed Actor Systems with Rust
Explore a prototype for a high-performance, type-safe distributed actor system in Rust, enabling complex and extensible distributed systems development with idiomatic code and efficient message handling.
Fearless Concurrency in Your Microcontroller
Explore efficient multitasking on microcontrollers using Rust's zero-cost, memory-safe abstractions for embedded systems. Learn about concurrent programming techniques for resource-constrained environments.
Tokio - How We Hit 88mph
Explore async I/O in Rust with Tokio, diving into futures, concurrency, and efficient server design. Learn how Rust's strengths are leveraged for high-performance asynchronous programming.
A Hammer You Can Only Hold by the Handle
Exploring Rust's type system to enforce API constraints and create self-documenting code. Learn how to leverage affine types for compile-time safety in complex operations.
Rust - An Alternative to High-Level Programming Languages
Exploring Rust's potential as a high-level language alternative, focusing on type safety, performance, and complexity for application development beyond systems programming.
Monotron - Making a 80s Style Computer with a $20 Dev Kit
Recreating 80s-style computing with embedded Rust on a Cortex M4 devboard: VGA generation, text rendering, PS/2 keyboard input, and testing on modern PCs.
Rustls - Modern, Faster, Safer TLS
Explore rustls, a modern TLS stack in Rust, offering enhanced security, performance, and design. Learn about its features, deployment, and advantages over traditional implementations.
Immutable Data Structures and Why You Want Them
Explore immutable data structures in Rust: their benefits, implementation, and performance advantages. Learn about innovative alternatives to standard library structures for efficient immutable operations.
A QUIC Future in Rust
Explore QUIC protocol implementation in Rust, its advantages over HTTP/2, and the future of serverside Rust using the futures ecosystem.
Vector Graphics Rendering on the GPU in Rust with Lyon
Explore GPU-based vector graphics rendering with Lyon, a Rust tool for games and applications. Learn about tessellation, challenges, and future developments in 2D graphics.
Scalable Networking with Rust
Discover how to build efficient real-time networking applications using Rust, MIO, and thread pools. Learn techniques for achieving 10X+ memory and CPU efficiency in backend systems.
Building Reliable Infrastructure in Rust
Techniques for building reliable infrastructure in Rust: advanced testing methods, bias reduction, and maximizing bug detection efficiency for distributed systems and databases.
Caging the SpiderMonkey - Ensuring Safe JS Bindings in Servo
Explore challenges and solutions in integrating SpiderMonkey with Servo, focusing on Rust's type system for enforcing safety rules and developing a custom compiler plugin for error verification.
Oh Boy! Creating a Game Boy Emulator in Rust
Explore Game Boy emulator creation in Rust, covering hardware aspects, implementation techniques, and deployment across multiple platforms including web browsers and mobile devices.
Declarative Programming in Rust
Explore declarative programming in Rust: techniques for better abstraction, maintainability, and code clarity. Learn from examples and apply to your own projects.
Rust, For Science!
Explore Rust's potential in scientific computing: its strengths, weaknesses, and areas for improvement. Learn about the language's applications in research and data science.
One Thousand Ways to Die in Rust FFI
Explore common pitfalls in Rust FFI, learn principles for writing safe and correct code, and discover effective strategies to avoid potential issues when working with foreign function interfaces.
Fun with Rusty Robots
Explore Rust programming for autonomous robots across various platforms, from bare metal to Linux and real-time OS, with practical insights for robotic competitions.
Sequoia - A New OpenPGP Implementation in Rust
Explore Sequoia, a new OpenPGP implementation in Rust, focusing on usability and security. Learn about challenges faced and solutions in API design, infinite types, and streaming iterators.
Zbus - Yet Another D-Bus Library
Explore zbus, a new D-Bus library for Rust. Learn about its design goals, development challenges, and solutions for efficient inter-process communication on Linux systems.
66 Hours of Rust
Experience report on learning Rust in 66 hours, exploring challenges and insights from a C# and TypeScript developer's perspective.