research.
writing and explorations across systems programming, web3, and software engineering, from the team.
At-Most-Once, At-Least-Once, and Exactly-Once: What Message Delivery Guarantees Really Mean
Your broker's delivery count is the wrong metric. At-most-once, at-least-once, and exactly-once semantics, and how to guarantee one committed effect per event.
Building a Raft Consensus Engine from Scratch in Rust
A full implementation of the Raft consensus algorithm in Rust — covering PreVote, joint consensus, leadership transfer, ReadIndex, snapshots, a segmented WAL, an in-process simulator, and Prometheus observability.
Building an Autonomous WC2026 Trading Bot: ELO, Monte Carlo, and Kelly Criterion on Polymarket
How we built an autonomous prediction market trading system using ELO ratings, Monte Carlo simulation, and Kelly criterion sizing on Polymarket for FIFA World Cup 2026.
Building a Production-Grade Slot-Based TWAP Oracle on Solana
A deep technical walkthrough of building a manipulation-resistant slot-weighted TWAP oracle on Solana: on-chain program, updater network, indexer, and security design.
What Solana Developers Get Wrong About Indexing
Why indexing is a protocol design decision, not an infrastructure afterthought — and how poor account design leads to fragile, non-replayable indexers.
Chain of Thought in Action
Exploring how chain-of-thought prompting works and its impact on LLM reasoning capabilities.
Not Just Replies, But Actions
Moving beyond simple LLM responses to building agents that can take meaningful actions in the real world.
Your LLM Doesn't Know You
Why personalization and context are key challenges in making LLM interactions truly useful.
The Hidden Language of AI
Understanding the representations and patterns that emerge inside neural networks.
Rookie Understanding of AI
A beginner-friendly introduction to AI concepts and how modern language models work under the hood.
Component Animation Using GSAP
How to create smooth, performant component animations using the GreenSock Animation Platform.
Cookie-Based Authentication: A Simple Guide for Secure Sessions
Straightforward guide to implementing secure cookie-based authentication with proper session management.
Need of Context API or Similar State Management Tools
Understanding when and why you need centralized state management in React applications.
Why Choose Next.js Over React
Comparing Next.js with vanilla React and when the framework's built-in features justify the additional complexity.
Is React Native Dead? The Shopify Paradox
Why the "Back to Native" hype is fundamentally wrong.
BlaBlaCar: Engineering Trust Into a Global Travel Network
How BlaBlaCar turned empty car seats into transport infrastructure, and why its real product was never just carpooling.
I Built an Event-Driven Order System Twice: First Incorrectly, Then Reliably
Transactional outboxes, idempotent consumers, compensation, and why “exactly once” is the wrong promise
Building a Reliable Job Queue in Rust: Leases, Idempotency, Retries, and the Limits of Exactly-Once
Leases, idempotency, retries, and why “exactly once” is the wrong promise
Understanding TypeScript's Handling of Object Literal Types
A look at TypeScript's excess property checking and the nuances of how object literal types behave.
When process.env Bites Back: A Node.js Performance Lesson
How excessive process.env access can silently degrade Node.js application performance, and what to do about it.
Video Diffusion Models: Teaching Machines to Imagine Motion
An exploration of how diffusion models are being adapted to generate coherent video sequences from noise.
Zero-Cost Abstractions in Rust: High-Level Code with Low-Level Performance
Understanding how Rust delivers zero-cost abstractions, enabling expressive code without sacrificing runtime performance.
Building a SWIM Gossip Membership Protocol from Scratch in Rust
Implementing the SWIM protocol for failure detection and membership management in distributed systems.
Building a Reliable TCP-like Transport over UDP in Rust
Exploring how to build reliable data transfer on top of unreliable UDP, implementing retransmission, ordering, and flow control.
Building a DNS Resolver from Scratch in Rust
A deep dive into implementing a DNS resolver using Rust, covering UDP sockets, DNS packet parsing, and recursive resolution.