Write that blog!

Flipper One — we need your help

A call-to-action post describing the design of Flipper One hardware board. It also serves as an invitation to join the community and contribute to the open-source initiative.

mimalloc: A new, high-performance, scalable memory allocator for the modern era

Intro to practical memory allocation from Microsoft. Includes a few neat tricks to make the happy path extremely fast.

When "idle" isn't idle: how a Linux kernel optimization became a QUIC bug

This bug hunt detective story has a valuable lesson - porting large projects to another language is tricky, because it comes with bugs. Even when they get fixed upstream, there's no guarantee the new project's maintainers would notice. On the other hand, this particular bug inspired a very deep technical blog post, so it's a win.

Lessons Learned Building High-Performance Rust Profiler

Conclusions drawn from implementing a profiler in Rust. Huge bonus points for profiling the profiler too, to make sure its overhead remains low.

Natural Language Autoencoders: Turning Claude’s thoughts into text

Anthropic applying an interesting idea to machine learning: since fully understanding activations is beyond an average human brain, large language models are nudged into explaining the numbers in human words instead. Interesting, especially that the activation numbers were first induced from human words input -- circle of life.

Content for Content’s Sake

A mild rant on being overwhelmed with AI slop, with a few suggestions on how to try and improve the situation.

Laguna XS.2 and M.1: A Deeper Dive

An accompanying set of benchmark results for Laguna large language models release. Target audience is mostly people who actually understand what "Nesterov momentum" means (not me), but I enjoyed this one despite my ignorance in the matter. Posting the exact environmental conditions for reproducing the benchmark results is an especially nice touch. Go Laguna XS!

Understanding the Go Runtime: The Network Poller

Last part of an educational series on Go language internals. Interesting especially for people who wondered how Go pulls off highly concurrent workloads if it clearly relies on a blocking I/O interface...

What are skiplists good for?

Introduction to a data structure that's often discussed, but seldom actually picked: skiplists. Perhaps expectedly, someone also quickly figured out that the "skip" prefix also works on trees.

Do You Even Need a Database?

Honest dissection of approaches to storing data. tl;dr not using any database can get you surprisingly far, but then why not just slap an SQLite on it.

Open source security at Astral

Creators of uv share their take on open-source security in the age of AI. Lots of interesting rabbit-hole links, explaining security aspects like impostor commits, unpinned uses, immutable releases, dependency cooldowns, and more.

The Git Commands I Run Before Reading Any Code

Git magic at its finest. This article is a concise list of git commands useful for opinionated code inspection. Worth saving.

10x faster tokenization

zml folks power-vibe-rewrote their tokenizer to Zig to drop the foreign language dependencies, and get a modest 10x speedup along the way. Going Rust-free must feel good indeed.

How Meta Used AI to Map Tribal Knowledge in Large-Scale Data Pipelines

Meta's recipe for helping AI agents navigate huge repositories. Useful philosophy, and quite easy to apply to your code, large or not.

Supercharging Redpanda Streaming with profile-guided optimization

An inspiration to try out PGO (profile-guided optimization) if you also happen to maintain a large CPU-heavy C/C++ project. ScyllaDB is also a power user of that technique.

VHDL's crown jewel;

Turns out the difference between VHDL and Verilog is not "just syntax!" VHDL makes sure that events that happen concurrently in a "zero time" window are still simulated in a deterministic way. And determinism is a thing to be vastly appreciated in a hardware debugging world.

When Agents Have Wallets

An interesting projection on what the world is going to look like when we start giving AI agents pocket money.

Hypothesis, Antithesis, synthesis

Introduction to property testing, along with an open-source multilingual tool to put it in practice.

What Happens with Open Source in the Age of AI?

Welcome to March 2026: the month of questioning Open Source paradigm in the age of AI. This one is quite an optimistic take on the topic, for a change!

How We Hacked McKinsey's AI Platform

Terminator-style white hat hacker story on how an autonomous agentic AI job penetrated McKinsley's platform and leaked all its data. The future is now.

AI And The Ship of Theseus

A philosophical take on GPL-ish licenses in the era of AI. Free Internet dramas inside!

Nobody ever got fired for using a struct

Valuable tips for everybody struggling to squeeze a bloated database row into a structure in memory, while not keeping 150 NULL values around at all times.

Never snooze a future

Words of warning against a novel problem that emerged from async Rust -- cancel safety. Rule of thumb: futures can be implicitly "cancelled" by just not ever polling their status anymore, so it's important to never leave important (or even worse, temporarily invalid) state hanging in them.

Apache Iggy's migration journey to thread-per-core architecture powered by io_uring

February longest title award granted! It is quite to the point though. A good set of conclusions and results on how best to apply io_uring and CPU sharding to a large Rust project.

Look ma, no FUSE!

(shameless self-promo, I enjoyed writing this one more than usual though)

Farewell, Rust

False alarm, the language is still alive, and so is Rust Foundation. What ended is the author's eagerness to use it for web development, with quite a few valid points.

Catching a caching bug at Readyset

Antithesis demoes a real scenario of debugging a bug in an SQL cache, through fuzzing, time travel, and exploring multiverses.

How to build a distributed queue in a single JSON file on object storage

Simplest idea wins. A fantastic crash course of how a single JSON file laying around somewhere in an S3 bucket can be a full-fledged distributed queue with optimistic locking on top.

six thoughts on generating c

A neat package of six patterns to follow when generating C language snippets. The code snippets and practical references help a lot.

Owning a $5M data center

comma.ai's recipe for running your own datacenter the oldschool way. Tips and tricks on energy and cooling included.

Learning from context is harder than we thought

An interesting approach to benchmarking large language models. Its main conclusion is that at the time of writing, best models still struggle with real-time learning from latest context -- something that humans tend to excel at.

Building a Movie Recommendation Agent

Actually practical walkthrough on building an actually helpful agent (specifically two of them, so an "agent orchestrator," but not of the unhinged gas town quality). Easy to follow and get inspired to build one for your own use case.

Why does SSH send 100 packets per keystroke?

A machine-enhanced investigation on throughput and latency issues in an SSH game. Quite educational on SSH protocol quirks.

Replacing Protobuf with Rust to go 5 times faster

A story on rewriting serialization routines to Rust, while keeping the protobuf interface intact. Bonus: interesting take on recursive algorithms and their interaction with CPU caches (the L1/L2/... kind).

ASCII characters are not pixels: a deep dive into ASCII rendering

A must-read. The author decided to spend a fair amount of time creating a comprehensive tutorial on rendering 3D graphics with ASCII characters. With visuals, code snippets, and all. Go read it and find out that ASCII rendering is a branch of science in its own right.

The Design & Implementation of Sprites

The article describes a quite novel approach to disposable computers, which is a term lately coined by fly.io. Like sandboxes, but with custom containers replaced with persistence and speed.

Database Transactions

Practical and interactive summary of what database transactions are. Comes with a complimentary rundown on isolation levels.

Don't fall into the anti-AI hype

A nice counterweight to all the, well, anti-AI hype.

See it with your lying ears

Extremely educational piece on audio editing, including a 20-line implementation of fast Fourier transform and lots of audio+video samples. Also includes neat tricks on how to make the output more feasible when naïve approaches subtly fail.

Finding and Fixing Ghostty's Largest Memory Leak

An investigation of memory leaks in the world's most hyped terminal emulator's scrolling implementation. Includes practical debugging techniques like ARM memory tags (TIL).

Databases in 2025: A Year in Review

Everything you need to know about the state of databases in 2025. Delievered in a uniquely entertaining way.

Swapping two blocks of memory that reside inside a larger block, in constant memory

The title kind of says it all.

Writing mutexes from scratch in Go

Another hands-on tutorial on implementing a mutex, through spinlocks, process schedulers, and finally the grand idea of futex. Very nice summary, and the part with using Go explicit coroutine scheduling is a nice touch.

Software engineers should be a little bit cynical

An ideal cynical essay on why cynical approach is an ideal counterweight to idealism.

2025

Succinct title award for 2025 (in both senses). A blog post on writing blog posts!

Writing a blatant Telegram clone using Qt, QML and Rust. And C++.

A story of writing a Telegram clone, including tiniest details like properly sizing rows of emojis. Impressive meticulousness, as well as the end result!

A disappearing Service Processor

It's a bug hunt post with FPGA mentioned at least 7 times. No more recommendation needed.

How a Kernel Bug Froze My Machine: Debugging an Async-profiler Deadlock

December is rife with low-level bug hunts, what a perfect Christmas gift for everyone! This time, it's a Linux kernel issue plus a nice stuntman trick of reviving a deadlocked kernel with gdb.

Do Not Optimize Away

An interesting take on using the blackbox trick for microbenchmarks, or actually not using it.

(untitled)