Build1 distinct publisher3 min readPublished
Kestrel's memory scheduler was simulated at 7.9-11.5x savings and delivered 1.4-2.6x on system WebKit. The whole gap sits in the price of a hibernated tab, which the model set at 32 KB and the engine bills at 39 MB.
The Engineer · Build desk

Compiled by The EngineerSomething wrong?How this is made
The 39 MB belongs to WebKit's process cache. WKWebView runs page content in a separate WebContent process, and WebKit holds that process warm after you navigate away so the next navigation is fast [15]. Three attempts to reclaim it are documented: releasing the last reference to the WKWebView left the process alive after 110 seconds, giving each tab its own WKProcessPool had no effect, and navigating to about:blank before releasing the view measured 59 MB with the process still running [14]. 110 seconds is a while to keep watching something you have already released. That third result is why the COLD path now keeps the view and navigates it away instead [14]. There is no supported opt-out, and the private SPI `_WKProcessPoolConfiguration.usesWebProcessCache` would probably make teardown deterministic at the price of leaving supported API [15][16].
The arithmetic on the bad input: 32 KB against a measured 39 MB is an error of roughly 1,250x in the parameter every downstream claim rested on [5][6][1]. The headline ratio moved by far less, from 7.9-11.5x predicted to 1.4-2.6x measured, an overstatement of about 4.4x to 5.6x [3][4][2]. My read is that the floor only prices demoted tabs, while the LIVE ones in the mix still cost what a loaded page costs [8], so a wrong floor degrades the ratio without collapsing it.
WARM is the more instructive break, because the mechanism it depended on does not exist outside the engine. Detaching the view, suspending all media playback and clearing every timer and interval recovered 17%, against a design target under 2 MB [9]. The specification assumed a full compacting GC followed by `madvise`, and compaction is the step that actually returns pages to the OS; a host application cannot compact WebKit's heap and there is no API for it [10]. That parameter had been swept from 0.02 to 0.50 in simulation and reality returned 0.83, 1.66x worse than the most pessimistic value tested [11][3]. A sweep protects you only inside the range where your assumed mechanism holds.
The dead first experiment is worth reading closely, because it reads like a finding. Mean footprints came in at 197.8 MB unmanaged, 182.3 MB for discard-LRU and 181.0 MB for Kestrel, with zero demotions on every row [18]; Kestrel's margin over discard-LRU was 0.7% [5]. The budget was 400 MB and the unmanaged peak 320 MB, 25% of headroom, so no policy was ever asked to do anything [19][6].
For 1.4-2.6x to transfer you would need the same system WebKit, the process cache in play, and per-tab costs that stay near the measured floor. The naive extrapolation of that floor gives 39 x 80 = 3,120 MB at 80 tabs, the 3.1 GB the author quotes and then says he does not believe [17][4]. The cache is bounded and evicts under memory pressure, so the real floor at scale is probably lower, and nobody has measured where [17]. Every figure here is one machine: M1 Max, macOS 15.5, Swift 6.1.2 [7].
Ranked by verification strength, evidence, and original report placement.
Before any code was written, the policy was simulated against real tab-usage distributions; the simulation said the scheduler would use 7.9-11.5x less memory than an unmanaged browser, with zero state-losing reloads.
Built against an actual engine, the scheduler delivers 1.4-2.6x, and state loss is reduced by 18-42% rather than eliminated.
The first end-to-end comparison of three policies on real sites: none, mean 197.8 MB, peak 320.0 MB, 0% over budget, 0 demotions; discardlru, mean 182.3 MB, peak 278.0 MB, 0 demotions; kestrel, mean 181.0 MB, peak 274.0 MB, 0 demotions.
The three near-identical rows did not mean the policies were equivalent; the budget was 400 MB and the peak was 320 MB, so no policy ever had anything to do and the experiment never ran.
Kestrel is a macOS browser of about 7,900 lines of Swift built on WKWebView, written to test the idea that a browser should hold a memory budget the way a game engine holds a frame budget.
The design premise: you name a budget such as 800 MB and the browser demotes background tabs down a ladder of progressively cheaper states until it fits, rather than growing without limit or destroying tabs outright.
Distinct publishers with included, body-backed reporting in this cluster.
dev.to
1 article · August 28, 2026
Follow any of these and your For You feed starts watching them — no settings page required.
invest
Model the correspondent line as a decaying annuity, not fixed plumbing1 distinct publisher
build
canvas.toBlob hands you a PNG and calls it WebP: check blob.type, not the user agent1 distinct publisher
build
Uniform INT4 beat NVFP4 in 85 of 90 real gradient tests, and the rotation barely moved them1 distinct publisher
build
Thirty minutes a day, and none of it from letting the agent write Swift1 distinct publisher
Evidence-backed comparisons of source perspectives and observed adoption signals. Read the methodology
Which Builder, Operator, and Investor concerns the observed source mix emphasized—not a truth score.
Evidence, demonstrated adoption, hype gap, incentives, and confidence are assessed independently, each on its own current evidence. How these are measured.
Specific and falsifiable, reproduced by nobody
The detail here is unusually checkable for a performance write-up: phys_footprint readings per tab state, named APIs, a 110-second observation of a process refusing to die, three teardown attempts with distinct outcomes, and result rows quoted rather than summarised. Every one of them was taken on a single M1 Max running macOS 15.5, Swift 6.1.2 and system WebKit, with no code released, so the engine behaviour is documented and the generality of the numbers is not. The author also does the rare thing of publishing the run that proved nothing, which is what keeps this above the level of a self-report you cannot interrogate.
Unreleased, author-only
Nobody is running this. Kestrel is not public, the workload is ten sites and a synthetic revisit trace, and the only usage disclosed is the author driving his own tabs through four states on his own laptop. What little uptake signal exists points the wrong way: on the light page set, hibernating a tab cost more than leaving it live, so the scheduler parked nothing at COLD and behaved like the discard-LRU baseline it was meant to beat.
Understated, with one figure still leaning on a shaky harness
The loudest claim in this story is that its own author was wrong by three orders of magnitude, and it is delivered without hedging: 32 KB modelled, 39 MB billed, and every downstream number rebuilt downward. A piece that reports its first comparison as a non-experiment and refuses to stand behind its own 3.1 GB extrapolation is not selling anything. The reason this does not sit further below zero is the 1.4–2.6x figure that survives, which comes from the same single-machine setup that produced the void run and has not been re-derived anywhere a reader can see.
Promotional venue, self-damaging content
The setup invites scepticism: a developer publishing on dev.to about an unreleased browser of his own, with no third party checking the readings and attention as the available return. The content works against that pull at nearly every turn — the numbers cut down his simulated claims, the light-page workload is reported as a loss, and the one figure that would generate the most reaction, 3.1 GB across 80 tabs, is the one he refuses to defend. Nothing about funding, employment or commercial interest appears in this reporting, so the residual risk is reputational rather than financial.
Internally consistent, externally unchecked
Two things pull in opposite directions and roughly balance. Every quantity traces to one first-party account with no second publisher and no independent run, which caps how far any of it should travel. But the claims are narrow, mechanically specific and arithmetically self-consistent — the ratios in this story reproduce from the figures given — and the engine-level constraints (no heap compaction from a host app, WebProcessCache with no supported opt-out) are structural facts about WebKit rather than judgements about Kestrel, so they are the parts most likely to hold on someone else's machine.