Rethinking the support model

A year after launching a membership scheme built around simultaneous article-and-video releases, the structure is getting a reset. The original idea was straightforward: every piece shipped as both a written article and a video, with videos free on YouTube thanks to sponsors, Bronze members getting extra content like sample Rust apps, and Silver members seeing articles six months before everyone else.

That arrangement had problems. A single RSS feed meant non-patrons got notified about articles they couldn't read, and some paywalled pieces ended up on Reddit or Hacker News with understandably frustrated comments. The six-month exclusivity window turned out to be too long — by the time content unlocked, most people had moved on. And not all topics translate equally well to both formats; code-heavy pieces make for poor video.

The deeper issue was treating this like a product launch rather than a creative endeavor. Supporting a creator isn't buying access to a course; it's funding ongoing work. The revamped model reflects that: early access when something is ready, not on a fixed schedule. Articles go out first when they're done, videos follow when they're finished, and both go to Silver-tier patrons and GitHub Sponsors on Patreon and this site. Early access cuts won't include sponsored segments — just the content itself.

The shift also gives supporters two chances to catch inaccuracies before public release. As a test, an early access cut of All color is best-effort is already available, despite having hit YouTube previously.

Better feeds and fewer platforms

The public RSS feed now only lists articles readable in full, ending the problem of notifications that lead to paywalls. Silver-tier supporters get a separate private RSS feed for early access posts, with the address available on their profile page. There's also a commitment to post early access content directly on Patreon and GitHub Sponsors so non-RSS users aren't left out.

Ko-fi support is being dropped. It had no OAuth2 API, forcing an email login system that looked up subscriptions via Stripe, and it lacked the video hosting Patreon provides. Existing Ko-fi subscriptions were cancelled with refunds for the remainder of the month.

Community, casual posts, and unlocked content

A Discord server has been set up with tiered channels so members can discuss early access content without spoilers and share ideas for future topics. Patreon members were pulled in automatically; GitHub Sponsors needed a custom bot, coolbearbot, built in the home repository. Discord is a temporary home, acknowledged as such, but it's a place to start collaborating and connecting.

Expect more casual output as well — short blog posts and YouTube clips that don't require a month of deep research. Not everything needs to be polished to the same degree.

All previously exclusive material is now public, including:

A new article is also entering early access at the time of this announcement, visible on the front page while logged in. At Eurorust 2025 in Paris, there will be two live episodes of Self-directed Research recorded with James — a chance to meet in person.

Kernel Offload Without the Handshake Headache

It has been roughly two years since the first commit landed for ktls and its companion ktls-sys, a pair of Rust crates that wrap Kernel TLS offload. The project is still active work, and the gap it fills remains specific: once a TLS session exists, the kernel — or a supporting network interface — can take over framing, encryption and the rest of the connection's data path.

The crucial caveat is the phrase "once a TLS session exists." Nothing in kTLS removes the need for a userland TLS stack during the handshake. The protocol's opening exchanges — ClientHello/ServerHello, cipher-suite negotiation, certificate exchange and validation, and the final encrypted extensions — all still happen in user space. Only after the secure channel is established does the kernel step in to handle the steady-state traffic.

That split is by design and, from a maintainability standpoint, a useful one. Applications that want the throughput benefits of offloaded encryption can keep whatever TLS library they already use for connection setup, then hand the resulting session state to the kernel. The hard part of the negotiation phase stays in a well-tested userland implementation where debugging and feature iterations are far easier.

For those unfamiliar with the mechanism: kTLS operates on already-established connections, receiving the session keys and letting the kernel's crypto and record-layer logic take over. This moves per-record encryption out of the application process and, on capable NICs, off the CPU entirely. The Rust crates aim to expose that transition cleanly, without requiring developers to drop into C or hand-roll ioctl calls.