Claude Desktop on Linux freezes over a 27-byte reply

The developer behind the Dfb blog has traced Claude Desktop’s Linux freezes to a 27-byte telemetry reply the app never reads, in a November 13 post on Dfb. Each unread reply keeps a file descriptor open in Chromium’s renderer, and at about a thousand of them the renderer hits its limit of 1,024, so the window freezes or goes blank. If your Linux copy dies like that after a day or more of uptime, a restart starts the count over. Launching the app from a shell with a higher soft open-files limit should also push the limit back: in our runs the same leak got past 1,100 requests in bare Electron, though we did not test Claude Desktop itself.
How to stop the leak
The fix inside the app is only one line: .then(r => r.body?.cancel()) after the fetch that sends the presence clear, or navigator.sendBeacon in its place. The app loads its frontend from claude.ai at run time, so the author patches the official build. His build keeps a debugger attached to the window, catches the script that sends the clear and adds the line. With the body cancelled, his Electron 44.9.3 repro finished all 1,100 requests at 38 descriptors.
We tried the same fixes on Electron 44.9.3 with 1,100 requests, one run each. cancel(), reading the body with r.text() and sendBeacon all left the renderer flat at 32 descriptors. The server can close the leak too. A no-store reply with an empty body, or a 204, did not pile up. Without Cache-Control the count peaked at 59 and was back to 32 three seconds after the run. For Anthropic’s endpoint that is our inference: we measured it only against our own local server.
On the user side, the renderer inherits the soft limit of whatever launched the app. With ulimit -Sn 4096 in the launching shell, the leaking test page finished all 1,100 requests on Electron 44.9.3, 45.2.3 and 46.0.0-alpha.10, ending with 1,132 to 1,134 descriptors open (one run each). The leak stays; only the limit moves. For Claude Desktop this is an inference from bare Electron run with --no-sandbox. It fits what commenters report on a separate issue about the same leak, filed on October 1 by another user and still open. They say version 3.1623.4 raised the renderer’s soft limit to 524,288, which stopped the freezes while the leak went on, and that 4.23118.0 put it back to 1,024.
Why 27 bytes add up
The request is presence telemetry from the Code tab. When the window is hidden or idle, the app POSTs a clear with keepalive: true, a flag that lets a request outlive the page. It ends the call with .catch(()=>{}), so the reply, {"refresh_after_seconds":0}, is never read. The regular presence request does read its body.
Chromium passes a non-empty response body to the renderer in a 2 MiB shared-memory region, and each region costs one descriptor. Blink, Chromium’s rendering engine, normally copies the body into memory soon after it arrives. It skips that step when the response carries Cache-Control: no-store, so an unread no-store body keeps its descriptor until someone reads or cancels it. Garbage collection doesn’t free it: in the author’s repro all 800 Response objects were collected and 836 descriptors stayed open. The Datadog browser SDK bundled in the app was holding 801 of the replies, which made it the first suspect, but it isn’t the cause.
His frozen renderer had 942 such regions after 35 hours, and 938 of them held that one reply. A fresh renderer collected 45 an hour. Its soft limit is 1,024, while the browser process raises its own to 524,288. On Chrome 152, which his copy ran as Electron 44.9.3, a message whose descriptor can’t be delivered sticks in Chromium’s IPC channel, and every later message waits behind it. Chromium fixed that hang in Chrome 154. The renderer now exits with code 0 and the page still gets no error, and the author’s version of the app treats a clean exit as intentional and doesn’t reload the window.
The author calls the freezes “not that regular”. The gaps between them while he was patching the app were 11, 13, 2 and 8 days.
“Working as intended”
Chromium has tracked the leak as a P3 bug since 2024. The bug’s owner answered: “If you can read the Response, but choose not to, I think this is working as intended. The browser cannot know that you won’t read the response in future, so it has to hold on to it.” A later comment proposes buffering fully received bodies under about 512 KB. The reporter wrote that “Many web app use bare fetch() to request no-empty response with no-store but never read it.” The author filed his own Chromium report, asking for fetch() to reject with a TypeError when no descriptor is available. It was closed the same day as a duplicate.
At Anthropic, a bot labelled his GitHub issue invalid 50 seconds after he filed it, with the note “Closing for now — this doesn’t appear to be about Claude Code,” and closed it three days later. The request comes from the Code tab, which, as the author points out, is Claude Code.
Our analysis
What we checked
On November 14 we ran the author’s test page with a soft limit of 1,024 on Electron 44.9.3, 45.2.3 and 46.0.0-alpha.10 (arm64, --no-sandbox). We also unpacked the newest Claude Desktop package in Anthropic’s apt repository.
The leak reproduces as described, but the version the author debugged is no longer what ships. His post says Claude Desktop is still on Chrome 152 without Chromium’s fix. The current package runs Electron 45.2.1 with Chrome 156 and still sends the clear without reading the reply. On Chrome 156 our runs ended with a silent renderer exit instead of a hang, so that is the likely symptom on an up-to-date install. That is our inference: we did not run Claude Desktop, and the frontend it loads at run time may differ from the bundled copy.
| Build | Result, soft limit 1,024 | Runs |
|---|---|---|
| Electron 44.9.3 (Chrome 152) | Page stops at “fetched 900” with the renderer at 1,024 descriptors, 993 of them leaked regions; JS keeps running without keepalive and stops answering with it | 2 per mode |
| Electron 45.2.3 (Chrome 156) | Renderer exits after “fetched 900”, clean-exit, code 0, with and without keepalive | 3 without keepalive |
| Electron 46.0.0-alpha.10 (Chrome 159) | Same as 45.2.3 | 3 without keepalive |
| Electron 44.9.3 in a container with 64 MB /dev/shm | After 30 unread replies, every further fetch() fails with TypeError: Failed to fetch (1,070 of 1,100) | 1 |
The author’s table has JS still running without keepalive on 45.2.3 and the 46 alpha. Our setup differs from his, so we could not reproduce those results, but that does not show they are wrong. In containers with the default 64 MB /dev/shm on Chrome 152, the same bug shows up as swallowed fetch errors after 30 requests, long before the descriptor limit is reached.
Up next
Anthropic faces a trademark suit over the Mythos name
One word, Mythos, is now at the center of a trademark lawsuit against Anthropic, per Reuters. The suit goes after the model’s name itself, not anything the model does. Do you run a trademark search before naming a project?
Related stories
- Claude Code sends file hashes to Anthropic even on DeepSeek
- Claude desktop teardown: MCP servers run outside the VM
- Claude limit meter may charge 1.4x more in US mornings
- Claude Opus 5.5 finished Baldur’s Gate 3 alone in 38.9 hours
- Claude Code hackathon in Japan arms 250 builders with Max 5x
- Claude’s cipher project writes off the gold bar codes
Comments
No comments yet. Be the first.
Join the conversation
Sign in to leave a comment. It appears after moderation.

