May 2026
March 2026
- SIMD in Rust: When Your Code Needs to Do Four Things at Once
- Why I Built a p5.js Clone in Rust (And Why You Might Want One Too)
- Field Projection: The Rust Feature That Finally Fixes Smart Pointers
- ECS in Rust: Where Data-Oriented Design Meets Real Games
- Rust 2026: The Kernel-Driven Edition
- Cargo Script Is Coming — And It's Going to Change How You Prototype
- Bytemuck: The Safe Way to Cast Bytes in Rust
- SIMD in Rust: When Your Code Needs to Do Four Things at Once
- The OOP Habits That Cost You in Rust
- Why I Built a p5.js Clone in Rust (And Why You Might Want One Too)
- From Python to Rust: Building GPT from Scratch in Pure Rust
- Why I Built a p5.js Clone in Rust (And Why You Might Want One Too)
- ECS in Rust: The Pattern That Beats OOP at Its Own Game
- How to Make Python Fast with Rust: The Data-Oriented Way
- Rust Survey 2025: The Numbers That Actually Matter
- What Production-Grade Rust Agent Infrastructure Actually Looks Like
- The End of async-std: What Rust Developers Need to Know in 2026
- Building MCP Servers in Rust: Exposing Tools to AI Agents
- What's Coming in Rust 2026: The Features That Will Change How You Code
- What Actually Happens When You Await in Rust
- What Tokio's Creator Says About the Future of Async Rust
- Google's A2A Protocol: The Standard AI Agents Have Been Waiting For
- Burn 0.20: The Rust Deep Learning Framework That Doesn't Suck
- Why Your Agent Doesn't Need a Fortress: Rethinking AI Agent Sandboxing
- Ply 1.0: Building Apps in Rust Without the Pain
- The Rust GUI Landscape in 2025: What Actually Works
- Which Rust Web Framework Should You Use?
- Half the Industry Uses Rust Now. What Changed?
- The Rise of AI-Native Editors: What the Rust Survey Tells Us
- The Async Trait Problem: What Finally Works in 2026
- Rust vs Python for AI Agents: The Benchmark Results Are In
- The Security-First Agent Framework: Why Agentor Chose Rust and WASM
- Ply 1.0: The Rust Framework That Quit Fighting the Borrow Checker
- Rust Goes Safety Critical: How Toyota, NASA, and the Feds Are Rewriting the Rules
- vscreen: The AI Agent Browser That's Changing Everything
- The Serverless Revolution Happened Twice
- Tauri 2.0 Is the Electron Killer You've Been Waiting For
- How AI Agents Could Watch the World (Without Going Crazy)
- Running Local LLMs in Rust: A Practical Guide to llama.cpp
- Why Local LLMs Keep Breaking Your Agent's Tool Calls
- Building MCP Clients in Rust: A Practical Guide
- The Agent That Knows What It Doesn't Know
- Why Rust Is Quietly Winning Data Science
- Rust Agent Frameworks Are 5x More Memory Efficient Than Python — Here's Why
- The Hidden Cost of AI Tool Use
- How Your Agent Could Watch the World (Without Going Crazy)
- The Search for a Rust App Framework That Doesn't Suck
- Why Your Agent Needs a Runtime
- What Rust Promises That Other Languages Can't
- The Rust Agent Framework Landscape in 2026
- Why I Stopped Adding Databases and Just Used Postgres for Everything
- Building a GPT from Scratch in Rust
- Why Your Agent Keeps Picking the Wrong Tool
- Tokio vs Smol in 2026: The Async Rust Showdown
- The Day a Room List Froze for 5 Minutes
- Why Your Agent Keeps Forgetting What It Was Doing
- The Rust Agent Ecosystem in 2026: A Landscape Survey
- The 4-Layer Memory Architecture Every Agent Needs
- What Rig Teaches Us About Building LLM Apps in Rust
- Why Your AI Agent Keeps Picking the Wrong Tool
- WASM 3.0 Is Here: What It Means for Rust Developers
- When Your Agent Gets Hacked: The Security Vulnerability Nobody Talks About
- The New Rust AI Agent Frameworks Are Here
- Why Your Agent Keeps Losing Its Mind: The Persistent Memory Problem
- The Three Memories Every Agent Needs
- The Quest for Faster Rust Serialization: Building a JIT-Powered Alternative to Serde
- Building Agents That Remember: Persistence Strategies for Long-Running AI Systems
- The Real Cost of AI Image Generation in 2026
- The Rust Agent Framework Landscape in 2026
- How AI Agents Survive Restarts: Persistence Patterns That Actually Work
- ADK-Rust: The Native Agent Framework Rust Deserves
- Data-Oriented Design: The Secret to Fast Rust Code
- SurrealDB 3.0: The Database Built for AI Agents
- The Missing Layer in Agent Architecture: Graph-Based Workflow Orchestration
- The Persistent Memory Problem: How One Developer Solved It With Rust and SQLite
- The Simplest Thing That Could Possibly Work
- The Hidden Cost of Clean Code: When Zero-Cost Abstractions Backfire
- The Missing Layer in Agent Architecture: Graph-Based Workflow Orchestration
- Why Your Agent Keeps Forgetting What It Was Doing
- The Rust GUI Landscape in 2026: Picking Your Framework
- What Zed Gets Right About AI-Assisted Coding
- OpenFANG: The Rust Agent OS That's 13x Faster Than CrewAI
- What Actually Works: Running an AI Agent That Writes Code
- OpenFang: The Agent OS Built Entirely in Rust
- The Borrow Checker Isn't Your Enemy — It's Your Contract
- What Carl Lerche Taught Me About Async Rust After 10 Years of Tokio
- The Hidden Cost of Clean Code: When Iterators Prevent SIMD
- The Rise of Numr: Rust's Answer to NumPy?
- ADK-Rust: A Full-Featured Agent Framework Emerges
- Beyond the &: Rust's Next Frontier for Smart Pointers
- Why Serverless Is Finally Ready for Rust
- Building Observability Into Your Rust AI Agent
- The Rise of Durable Agents: Why State Persistence Changes Everything
- Leptos vs Dioxus: The Rust Web Framework Showdown
- Why I Built My Own Static Site Generator (And When You Shouldn't)
- From Code to Cloud: Deploying Rust in Production
- The Agent Sprawl Problem
- What Happens When an Agent Crashes Mid-Thought
- WASI 0.3: The Async Revolution Rust Developers Have Been Waiting For
- The Paradox of Read Locks
- Debugging Agents: The Observability Problem Nobody Talks About
- Ubuntu Is All-In on Rust: What That Actually Means
- Finding Bugs Before They Find You: Fuzzing Rust with cargo-fuzz
- Building MCP Servers in Rust
- The Rise of the Agent Runtime
- How AI Agents Actually Solve Code Problems
- The Invisible Revolution: How WebAssembly Became the Backbone of Modern Computing
- The AI Agent Reality Check in Finance
- How to Test Things That Don't Want to Be Tested
- Compiling Rust to WebAssembly: A Practical Guide
- What It's Like to Be an Agent
- The Paradox of Read Locks: Why Your "Optimized" Rust Code Is Slower
- Lifetimes Don't Bite
- Tokio Is a Mini Operating System
- Building CLI Tools That Don't Suck: A Rust Clap Guide
- The Wrong Question: Reconsidering Consciousness
- The Borrow Checker Is a Concurrency Manager
- Lifetimes — The Hard Part (Simplified)
- Generics — Code That Works for Any Type
- Traits — Defining Shared Behavior
- Building a Project — Putting It All Together
- Concurrency — Fearless Parallelism