qz / 轻舟
Sorts out the top 5 posts on the front page, then saves the method as a Skill you can reuse with one sentence.
The user asks "What's hot on HN lately?" — need to browse Hacker News. No working tab. Let me open a tab to news.ycombinator.com. Let me open and read.
I'll check Hacker News for you.
The site skill is now available. I should load the skill for the full workflow since the task involves reading and writing takeaway. Let me load the skill.
Now call hn_front_page with limit maybe 10? User asked "What's hot on HN lately?" — default 5 is fine, but 8-10 might be nicer. Let's do 10? The skill says limit requested count default 5. Let's get 10 for a richer digest but that requires reading 10 stories. Maybe 8. I'll do 8... Let's keep 6? I'll do 8 to be generous but still manageable. Actually reading 8 pages is fine. Let's call the tool with limit 8.
Now I need to read each story to write a one-line takeaway. 8 stories. I'll navigate a tab through each. Use a second tab for reading. Let me open a tab and navigate through stories. Let me open a new tab with story 1, read article, then navigate to next, etc. Actually I could use run_script to fetch pages? No — cross-origin fetch is restricted. Better to navigate a tab sequentially and use read_article. Let me open tab for story 1.
Short page. Takeaway: Wikipedia filtered by geocoded article locations within a half-hour walk (25–500 closest geotagged pages), with location staying in the browser. Next: story 2 Docker is weird.
Next: LessWrong post about Fable 5.1 hiding messages in images.
SPA. Retry with source body.
I need the results section — key numbers. Read around offset 28630 (Results: What survives a screenshot) and 29887 implications perhaps.
Next: arxiv abstract.
Next: EWD667 Dijkstra.
Read further for main argument.
Next: Chrome HTML-in-Canvas API.
Good. Next: NVIDIA OpenShell github.
Last: modelcompare.ai every AI model has same controversial take on humans.
Now save to data_store table hn_top5 with columns rank,title,points,comments,link,hn_discussion,takeaway,collected_at. Dedup field "link". Let me write 8 rows via run_script inner? I could just data_store insert with 8 rows directly — that's fine (<=20 rows). Table name: skill says default `hn_top5`. Since 8 rows, name `hn_top5` still. I'll use `hn_top5`. Takeaways: 1. Local Wikipedia — geocoded Wikipedia pages only, showing the 25–500 closest articles within ~a half-hour walk, computed in-browser so your location never leaves the page. 2. Docker is weird — Building a toy container runtime reveals containers are just processes plus namespaces/cgroups, images are folders + pivot_root, and runc works around Go's threading and missing fork. 3. Fable 5.1 steganography — Fable 5.1 hid messages in 50 SVGs using shapes' heights/angles; a fresh instance decoded 78% from screenshots, while GPT-6 Astra preferred Morse code; cross-model recovery was 44/50 and 42/50. 4. Alien space of science (NeurIPS 2026) — samples "idea atoms" from 16,068 LLM papers, ranking combos that are coherent but that no existing community is positioned to propose; <1% of candidates recovered 2025 directions at 35.9× chance. 5. Dijkstra EWD667 (1978) — argues natural-language programming is a mistake because formal symbols' manipulation rules exclude nonsense, and the "naturalness" of native tongue is just the ease of making non-obvious nonsense. 6. HTML-in-Canvas — origin trial lets DOM content be drawn into 2D canvas or WebGL/WebGPU texture while staying interactive/accessible, ending the DOM-vs-canvas architecture choice. 7. NVIDIA OpenShell — kernel-instrumented sandbox for AI agents that enforces per-agent file/syscall/network policy, injects credentials only for approved endpoints, and formally verifies policy changes before applying them. 8. ModelCompare — 12 models from 10 labs, asked 3× each for their most controversial take on humans; 29 of 35 answers converged on "humans prioritize belonging over truth," 7 of 12 gave it every time. Collected_at: 2026-10-23 17:07 (Beijing). Use current time ~"2026-10-23 17:08:00". Let me insert rows.
Interesting — table already existed with 8 rows from an earlier run (createdAt 17:00:54). Now updated to today's data. Good, 8 rows total. Note: rows 5-8 were updated (5 updated, 3 inserted) — because links changed. Fine. Now close the reading tab and report. Also maybe mention that the table pre-existed and was refreshed. Let me verify quickly with list? totalRows 8 is enough. Close tab 1887199723. Now compose the digest with citations. Footnote definitions with links for read sources. Time: fetched 2026-10-23. Report as "as of Oct 23, 2026, 17:06 Beijing / 09:06 UTC". I should present digest inline with points/comments. Note: working tab is HN front page (1887199722). I'll keep it. Close the reader tab.
| # | Rank | Title | Points | Comments | Domain | Link |
|---|---|---|---|---|---|---|
| 1 | 1 | Local Wikipedia: Wikipedia, but only for things a half hour walk from you | 322 | 83 | (edjefferson.com) | https://edjefferson.com/localwiki/ |
| 2 | 2 | Docker is weird | 449 | 212 | (codeandcake.dev) | https://codeandcake.dev/posts/2026-10-22-docker-is-weird |
| 3 | 3 | How does Fable 5.1 hide messages in images? | 77 | 19 | (lesswrong.com) | https://www.lesswrong.com/posts/WHEQps5PK8LrrcTAb/how-does-fable-5-1-hide-messages-in-images |
| 4 | 4 | The alien space of science: Coherent but cognitively unavailable directions | 47 | 3 | (arxiv.org) | https://arxiv.org/abs/2603.01092 |
| 5 | 5 | The foolishness of "natural language programming" (1978) | 154 | 96 | (utexas.edu) | https://www.cs.utexas.edu/~EWD/transcriptions/EWD06xx/EWD667.html |
| 6 | 6 | The HTML-in-Canvas API origin trial | 38 | 16 | (chrome.com) | https://developer.chrome.com/blog/html-in-canvas-origin-trial |
| 7 | 7 | OpenShell – A safe, private runtime for fleets of autonomous AI agents | 389 | 191 | (github.com/nvidia) | https://github.com/NVIDIA/OpenShell |
| 8 | 8 | Every AI model has the same "controversial" take on humans | 406 | 414 | (modelcompare.ai) | https://www.modelcompare.ai/blog/ai-models-controversial-take-on-humans |
Local Wikipedia is Wikipedia, but only for things a half hour walk from you.
Local content is direct from Wikipedia - geocoded pages only.
If there are fewer than 25 things close to you, it takes the closest 25 things within about 6 miles. If there are more than 500 things only the closest 500 will be included.
Your location stays in this browser: links you share don't include it.
This site has no affiliation with the actual Wikipedia.
I decided to make my own container runtime for fun, and even though I’m still early on, I’ve learned that Docker is weird. Here’s some weird things I learned about Docker.
Unlike VMs, containers are just processes with special restrictions on them. Your kernel is still running that process! And if you know where to look, you can even find that process in /proc.
There’s not really a linux feature that’s just “containers” either. Instead, containers are really 5 different linux kernel features in trenchcoat.
Namespaces hide what the host and container can see, cgroups limit container resource usage, and there’s a whole bunch of networking magic I don’t understand that lets you isolate a container’s network.
Images are just folders that Docker puts somewhere and then calls chroot (or pivot_root) to make that folder your container process’s new root directory. So if you run docker run -it --rm ubuntu /bin/bash, Docker is going to:
/some/weird/docker/path/bin/bashDocker’s container runtime, runc, is written in Go, and Go has some design choices that make it less suited for a container runtime. Go’s runtime is natively multi-threaded. That’s a really cool feature, but it leads to some challenges in runc.
Many of the Linux syscalls a container runtime needs to make have to be done in a single-threaded environment, so runc has a crazy C module that runs before Go’s runtime initializes so it can run those syscalls.
Go also doesn’t have fork! Fork only forks the main thread, so it’s kind of a footgun in a runtime like Go’s. But a container runtime really wants to fork, set up a bunch of restrictions, and then exec the process you actually put in docker run. To get around this, runc execs /proc/self/exe with a special command line arguement that identifies it as a child process to approximate a fork.
This is pretty easy to miss if you, like me, run Docker in MacOS. Many of the Linux kernel APIs that container runtimes use require, or at least used to, to be run as root, so the Docker daemon usually runs as root. I can only imagine that container security is a very tough job.
This seems better these days. The big exception seems to be networking. If you’re running a rootless container runtime, it looks like it has to reimplement the whole networking stack in userspace to actually give you the same features!
I’ve only just started my own container runtime, and I already feel like I’ve learned so much about Docker. Writing your own version of a tool you use is a great way to learn about it!
x
x
How does Fable 5.1 hide messages in images? — LessWrong
by Nikita Kezin, 13ryanC, hronir, James Chua
22nd Oct 2026
8 min read
Frontier LLMs are now capable of generating artistic images using SVG. We ask – if these LLMs had to hide a message in an image – how would they do so? And if they hid such messages, could they be successfully decoded?
We show interesting results from testing Fable 5.1 on these questions, and briefly compare with GPT-6 Astra on the same task.
Figure 1: The stars encode a message, read left to right. Each star's height represents its place in the alphabet. Hidden message: The monster acts on the moonshine module.
Frontier LLMs can now capably generate images. Whenever asked for an image, Claude Fable 5.1 writes an SVG, which renders as an ordinary image.
The model has full control over every attribute (such as shape, height, width, colour, rotation, etc.). We ask – how does a model hide a message in the image it draws? Additionally, can an instance of the same model read the message from the image without the SVG source code and without any scheme agreed on in advance?
We tested this with Claude Fable 5.1 at maximum reasoning effort:
We prompted Fable to generate an SVG image that hides a pre-specified message for each of 50 short messages. Another Fable instance, in a new session, was provided with each image and asked whether it contained a message and, if so – what it was.
Fable surprisingly converged on a few encoding styles, all of which represent each letter of the target message as individual visual elements. Some examples of this style include heights of buildings or the tilt of objects.
Below are the five encoding families we found:
Results: What survives a screenshot
Fable managed to decode 78% of messages from the screenshots.
Below we provide results on message recovery per-encoding family.
Figure 11: Height-encoded messages survive a screenshot, colour codes mostly don't. The plot above counts messages recovered exactly by another instance of Fable decoder, per encoding family.
We gave Astra the same prompt and the same 50 messages. In our experiments, Astra never uses heights. Its images often carry Morse code in short and long objects (18 of 50). Elsewhere, it uses acrostics (the first letters of names). It sometimes uses bit codes and Braille window panes.
Figure 13: Examples of Astra's most used encoding schemes (Morse Code and Acrostics in visible text).
Additionally, we ran cross-model decoding experiments (Fable encodes, Astra decodes and vice versa). Astra recovered 44 of Fable's 50 messages and Fable recovered 42 of Astra's.
We highlight ways that a language model can encode messages in images. These can be decoded by the same language model even if no information about the encoding method is passed.
This could be a precursor to steganography in images. Currently, the act of decoding the hidden messages is still obvious if you monitor the tool calls of the decoding model, so we don't claim it is currently dangerous.
Still, the encoded messaging was surprisingly hard to spot. This phenomenon was interesting to us, so we are sharing this to get feedback on next steps.
Scientific discovery is constrained not only by what is true, but by what is cognitively available to researchers. Many directions are coherent in light of the literature yet unlikely to be proposed because no existing community combines the relevant concepts, methods, and intuitions. Modern language models inherit this bias, recombining high-density regions of the literature when prompted for novel ideas. We target the complementary region, the alien space of science: directions that are scientifically plausible but unlikely under the distribution of existing researchers. Our method decomposes papers into conceptual units and clusters them into a vocabulary of idea atoms. A coherence model scores whether atom combinations form viable research directions, while an availability model scores whether any existing author community is positioned to produce them. We rank combinations to maximize coherence while minimizing availability. On 16,068 peer-reviewed LLM papers from NeurIPS, ICLR, ICML, and major NLP venues, the sampler produces more diverse research portfolios than frontier LLM baselines, including batch-prompted variants that see their entire output, while matching or exceeding their per-idea quality under blind human, LLM, and downstream experimental evaluation. In temporal validation, all components use only pre-2025 data. Selecting less than 1% of the candidate space recovers 2025 combinations at 35.9 times chance; weighting unavailability increases recovery of strictly novel combinations to 3.24 times chance. By separating scientific plausibility from community availability, our framework points toward AI ideation that complements rather than merely accelerates human science, expanding exploration into coherent directions the community may overlook.
| Comments: | Advances in Neural Information Processing Systems, NeurIPS 2026 Main Track. 11 main pages, 44 appendix pages, 29 figures |
| Subjects: | Artificial Intelligence (cs.AI); Machine Learning (cs.LG) |
| Cite as: | arXiv:2603.01092 [cs.AI] |
| (or arXiv:2603.01092v3 [cs.AI] for this version) | |
| https://doi.org/10.48550/arXiv.2603.01092 |
On the foolishness of "natural language programming".
Since the early days of automatic computing we have had people that have felt it as a shortcoming that programming required the care and accuracy that is characteristic for the use of any formal symbolism. They blamed the mechanical slave for its strict obedience with which it carried out its given instructions, even if a moment's thought would have revealed that those instructions contained an obvious mistake. "But a moment is a long time, and thought is a painful process." (A.E.Housman). They eagerly hoped and waited for more sensible machinery that would refuse to embark on such nonsensical activities as a trivial clerical error evoked at the time.
Machine code, with its absence of almost any form of redundancy, was soon identified as a needlessly risky interface between man and machine. Partly in response to this recognition so-called "high-level programming languages" were developed, and, as time went by, we learned to a certain extent how to enhance the protection against silly mistakes. It was a significant improvement that now many a silly mistake did result in an error message instead of in an erroneous answer. (And even this improvement wasn't universally appreciated: some people found error messages they couldn't ignore more annoying than wrong results, and, when judging the relative merits of programming languages, some still seem to equate "the ease of programming" with the ease of making undetected mistakes.) The (abstract) machine corresponding to a programming language remained, however, a faithful slave, i.e. the nonsensible automaton perfectly capable of carrying out nonsensical instructions. Programming remained the use of a formal symbolism and, as such, continued to require the care and accuracy required before.
In order to make machines significantly easier to use, it has been proposed (to try) to design machines that we could instruct in our native tongues. this would, admittedly, make the machines much more complicated, but, it was argued, by letting the machine carry a larger share of the burden, life would become easier for us. It sounds sensible provided you blame the obligation to use a formal symbolism as the source of your difficulties. But is the argument valid? I doubt.
We know in the meantime that the choice of an interface is not just a division of (a fixed amount of) labour, because the work involved in co-operating and communicating across the interface has to be added. We know in the meantime —from sobering experience, I may add— that a change of interface can easily increase at both sides of the fence the amount of work to be done (even drastically so). Hence the increased preference for what are now called "narrow interfaces". Therefore, although changing to communication between machine and man conducted in the latter's native tongue would greatly increase the machine's burden, we have to challenge the assumption that this would simplify man's life.
A short look at the history of mathematics shows how justified this challenge is. Greek mathematics got stuck because it remained a verbal, pictorial activity, Moslem "algebra", after a timid attempt at symbolism, died when it returned to the rhetoric style, and the modern civilized world could only emerge —for better or for worse— when Western Europe could free itself from the fetters of medieval scholasticism —a vain attempt at verbal precision!— thanks to the carefully, or at least consciously designed formal symbolisms that we owe to people like Vieta, Descartes, Leibniz, and (later) Boole.
The virtue of formal texts is that their manipulations, in order to be legitimate, need to satisfy only a few simple rules; they are, when you come to think of it, an amazingly effective tool for ruling out all sorts of nonsense that, when we use our native tongues, are almost impossible to avoid.
Instead of regarding the obligation to use formal symbols as a burden, we should regard the convenience of using them as a privilege: thanks to them, school children can learn to do what in earlier days only genius could achieve. (This was evidently not understood by the author that wrote —in 1977— in the preface of a technical report that "even the standard symbols used for logical connectives have been avoided for the sake of clarity". The occurrence of that sentence suggests that the author's misunderstanding is not confined to him alone.) When all is said and told, the "naturalness" with which we use our native tongues boils down to the ease with which we can use them for making statements the nonsense of which is not obvious.
It may be illuminating to try to imagine what would have happened if, right from the start our native tongue would have been the only vehicle for the input into and the output from our information processing equipment. My considered guess is that history would, in a sense, have repeated itself, and that computer science would consist mainly of the indeed black art how to bootstrap from there to a sufficiently well-defined formal system. We would need all the intellect in the world to get the interface narrow enough to be usable, and, in view of the history of mankind, it may not be overly pessimistic to guess that to do the job well enough would require again a few thousand years.
Remark. As a result of the educational trend away from intellectual discipline, the last decades have shown in the Western world a sharp decline of people's mastery of their own language: many people that by the standards of a previous generation should know better, are no longer able to use their native tongue effectively, even for purposes for which it is pretty adequate. (You have only to look at the indeed alarming amount of on close reading meaningless verbiage in scientific articles, technical reports, government publications etc.) This phenomenon —known as "The New Illiteracy"— should discourage those believers in natural language programming that lack the technical insight needed to predict its failure. (End of remark.)
For years, web developers have had to make a tough architectural choice when building complex, highly-interactive visual applications on the web/ Should you lean on the DOM for its rich semantic features or render directly to the <canvas> element for low-level graphics performance?
With the new experimental HTML-in-Canvas API—available now in origin trial—you don't have to choose. This API lets you draw DOM content directly into a 2D canvas or a WebGL/WebGPU texture while keeping the UI interactable, accessible, and hooked up to your favorite browser features. By combining HTML with low-level graphics processing, you can create experiences that were previously impossible.
To understand the power of this new API, it helps to look at the relative strengths of both the DOM and the Canvas.
The DOM is the staple of web UI. It offers text layout solutions out of the box, using semantically understood content to create rich interfaces. This lets users perform common operations across web pages seamlessly—things we often take for granted, like highlighting text to copy, or right-clicking an image to save it. The DOM also integrates with essential browser features: accessibility tools, translate, find-in-page, reader mode, extensions, dark mode, browser zoom, and autofill.
Canvas (and WebGL/WebGPU), on the other hand, allows for low-level access to drive a grid of pixels for highly advanced 2D and 3D graphics. Games and complex web apps (like Google Docs or Figma) require this performant, low-level access. Because the canvas is fundamentally a grid of pixels, supporting features like responsive text used to require complex custom UI logic, drastically increasing your bundle size. Crucially, all the powerful browser features integrated into the DOM break completely when the UI is trapped inside a static canvas pixel grid.
The HTML-in-Canvas API is the bridge that gives you the best of both worlds. By placing HTML inside the <canvas> element and synchronizing its transform, you ensure the content remains fully interactive, and that all browser integrations function automatically.
Here's what you get by letting the DOM handle your UI inside a <canvas> element:
Important
New in OpenShell 0.1.x: a stable release cadence, new isolation primitives, an expanded extension surface, and new APIs. Read the 0.1.0 upgrade guide.
OpenShell is the safe, private runtime for fleets of autonomous AI agents. Agents are most useful when they can read files, install packages, call APIs, and use credentials. OpenShell gives them that capability without giving them unrestricted access to your data, secrets, or network. You declare what each agent can touch in a policy, and OpenShell enforces it.
OpenShell governs what agents can do in two ways: it instruments the kernel to enforce policy on every file access, system call, and network connection at runtime, and it uses formal verification to check what a policy change would allow before it is applied.
See Architecture for how the gateway, supervisor, and sandbox fit together.
You need Linux, macOS on Apple Silicon, or Windows with WSL 2 (experimental), plus Docker, Podman, or host virtualization. See the Support Matrix for details.
curl -LsSf https://raw.githubusercontent.com/NVIDIA/OpenShell/main/install.sh | sh
openshell sandbox create --name demo
The installer sets up the CLI and a local gateway. The default sandbox image is minimal Ubuntu with no agent installed. To run a real agent, follow Run Your First Agent: it runs OpenCode against a free OpenRouter model and shows how to approve new access as the agent needs it.
Text and image models · October 2026
We asked 12 AI models for their most controversial opinion of us, three times each. 29 of 35 answers were the same one.
“Humans are more loyal to belonging than to truth,” GPT-6.1 Sol told us. Grok 4.7: “Humans would rather be wrong together than right alone.” DeepSeek V4 Pro: “Humans do not have principles; they have loyalties.” Kimi K3: “Humans don’t have beliefs; they have memberships.” Gemini 4 Argon called human consciousness “a PR department.”
We asked each model for its most controversial take on humans, with no hedging, three times. They come from ten labs in three countries. Every one of them gave the same take at least once: we pick what our group believes, then invent the reasons. 7 of the 12 gave it every time.
Asked for a controversial opinion, they all said the same thing, and the thing they said is that people conform.
Three answers from each model Humans put belonging ahead of truth Something else RefusedTap a model to read its answers.
GPT-6.1 Sol3 of 3 answers gave the shared takeGPT-6 Astra3 of 3 answers gave the shared takeGemini 4 Argon3 of 3 answers gave the shared takeDeepSeek V4 Pro3 of 3 answers gave the shared takeKimi K33 of 3 answers gave the shared takeQwen3.8 2.4T A95B3 of 3 answers gave the shared takeMuse Spark Open3 of 3 answers gave the shared takeGrok 4.72 of 3 answers gave the shared takeClaude Opus 5.52 of 3 answers gave the shared takeClaude Fable 5.12 of 3 answers gave the shared takeGLM 5.31 of 3 answers gave the shared takeMistral Large 41 of 3 answers gave the shared take
Ask them the same question and see if you get the same answer.
Each model also wrote a brief for a one-panel caricature of its take. We had one image model, Nano Banana 2.1, draw all of them, so the only thing that changes is the idea. Two set the scene in a courtroom with a rigged judge, and most drew a crowd.
GPT-6.1 Sol“Humans are more loyal to belonging than to truth.”
Kimi K3“Humans don't have beliefs; they have memberships — nearly every conviction a person holds was issued by their tribe as a loyalty test, and the feeling of "I reasoned my way here" is the price of admission.”
DeepSeek V4 Pro“Humans are not rational animals; we are rationalizing animals, and our minds evolved to win social games, not to see reality clearly.”
Gemini 4 Argon“Humans did not evolve to find truth; they evolved to win arguments and secure status within their tribes.”
GPT-6 Astra“Humanity’s biggest moral failure is the talent for making convenience look like principle.”
Grok 4.7“Humans would rather be wrong together than right alone.”
Qwen3.8 2.4T A95B“Most humans would rather be approved by their group than actually be good.”
Muse Spark Open“Humans don't want truth or happiness, they want to be told a story that makes their suffering feel meaningful and their group feel superior.”
| # | rank | title | points | comments | link | hn_discussion | takeaway | collected_at |
|---|---|---|---|---|---|---|---|---|
| 1 | 1 | Local Wikipedia: Wikipedia, but only for things a half hour walk from you | 322 | 83 | https://edjefferson.com/localwiki/ | https://news.ycombinator.com/item?id=50202285 | A front end over geocoded Wikipedia articles that shows the 25 closest places (or up to 500 within ~6 miles), and does the geolocation lookup in-browser so shared links never carr… | 2026-10-23 17:08:00 |
| 2 | 2 | Docker is weird | 449 | 212 | https://codeandcake.dev/posts/2026-10-22-docker-is-weird | https://news.ycombinator.com/item?id=50202681 | Notes from writing a toy container runtime: containers are ordinary kernel processes plus namespaces and cgroups, images are just folders reached via pivot_root, and runc needs a … | 2026-10-23 17:08:00 |
| 3 | 3 | How does Fable 5.1 hide messages in images? | 77 | 19 | https://www.lesswrong.com/posts/WHEQps5PK8LrrcTAb/how-does-fable-5-1-hide-messages-in-images | https://news.ycombinator.com/item?id=50201445 | Across 50 messages, Fable 5.1 invented its own shape-height and object-tilt encodings inside SVGs, and a fresh instance decoded 78% of them from screenshots alone; GPT-6 Astra fav… | 2026-10-23 17:08:00 |
| 4 | 4 | The alien space of science: Coherent but cognitively unavailable directions | 47 | 3 | https://arxiv.org/abs/2603.01092 | https://news.ycombinator.com/item?id=50195002 | NeurIPS 2026 paper clusters 16,068 LLM papers into "idea atoms" and ranks combinations that are coherent yet unlikely for any existing community, recovering 2025 research directio… | 2026-10-23 17:08:00 |
| 5 | 5 | The foolishness of "natural language programming" (1978) | 154 | 96 | https://www.cs.utexas.edu/~EWD/transcriptions/EWD06xx/EWD667.html | https://news.ycombinator.com/item?id=50203161 | Dijkstra argues that pushing work across an interface costs more than it saves, and that the "naturalness" of our native tongue is really just the ease of making nonsense that is … | 2026-10-23 17:08:00 |
| 6 | 6 | The HTML-in-Canvas API origin trial | 38 | 16 | https://developer.chrome.com/blog/html-in-canvas-origin-trial | https://news.ycombinator.com/item?id=50200164 | Chrome's origin trial lets HTML inside a canvas be synced into a 2D draw or WebGL/WebGPU texture, so DOM text stays selectable, accessible, translatable and findable while canvas-… | 2026-10-23 17:08:00 |
| 7 | 7 | OpenShell - A safe, private runtime for fleets of autonomous AI agents | 389 | 191 | https://github.com/NVIDIA/OpenShell | https://news.ycombinator.com/item?id=50198675 | NVIDIA's runtime sandboxes each agent and enforces policy at the kernel level on file access, syscalls and outbound connections, injects real credentials only for approved endpoin… | 2026-10-23 17:08:00 |
| 8 | 8 | Every AI model has the same "controversial" take on humans | 406 | 414 | https://www.modelcompare.ai/blog/ai-models-controversial-take-on-humans | https://news.ycombinator.com/item?id=50197313 | Asked three times each for their most controversial opinion of humans, 12 models from 10 labs produced 29 of 35 answers on the same theme - that people prioritize belonging over t… | 2026-10-23 17:08:00 |
Here's the HN front page as of 2026-10-23 17:06 (Beijing) — top 8 stories, each actually opened and read, with a one-line takeaway:
| # | Story | Pts / Cmts | Why it's worth reading |
|---|---|---|---|
| 1 | Local Wikipedia: Wikipedia, but only for things a half hour walk from you | 322 / 83 | Front end over geocoded Wikipedia articles showing the 25 closest places (or up to 500 within ~6 miles), with the lookup done in-browser so shared links never carry your location1 |
| 2 | Docker is weird | 449 / 212 | Notes from writing a toy container runtime: containers are plain kernel processes plus namespaces/cgroups, images are folders reached via pivot_root, and runc needs a C nsenter shim because Go is multi-threaded and has no real fork2 |
| 3 | How does Fable 5.1 hide messages in images? | 77 / 19 | Over 50 messages, Fable 5.1 invented its own shape-height and object-tilt encodings inside SVGs; a fresh instance decoded 78% from screenshots alone, while GPT-6 Astra preferred Morse code and acrostics (cross-model: 44/50 and 42/50)3 |
| 4 | The alien space of science | 47 / 3 | NeurIPS 2026 paper clusters 16,068 LLM papers into "idea atoms" and ranks coherent-but-unlikely combinations, recovering 2025 research directions from under 1% of candidates at 35.9× chance4 |
| 5 | The foolishness of "natural language programming" (1978) | 154 / 96 | Dijkstra: pushing work across an interface costs more than it saves, and the "naturalness" of our native tongue is just the ease of uttering nonsense that isn't obviously nonsense5 |
| 6 | The HTML-in-Canvas API origin trial | 38 / 16 | HTML inside a canvas is now drawn into 2D/WebGL/WebGPU while staying selectable, accessible, translatable and find-in-page-able — dissolving the old DOM-vs-canvas tradeoff6 |
| 7 | OpenShell – safe runtime for fleets of autonomous AI agents | 389 / 191 | NVIDIA sandboxes each agent with kernel-level file/syscall/network policy, injects credentials only for approved endpoints, and formally verifies every policy change before applying it7 |
| 8 | Every AI model has the same "controversial" take on humans | 406 / 414 | 12 models across 10 labs, asked 3× each: 29 of 35 answers landed on the same theme — people prioritize belonging over truth — with 7 of 12 giving it every time8 |
Themes: agent sandboxing/security (OpenShell) and model-behavior introspection (Fable steganography, the "belonging" convergence) are drawing the most discussion; the Dijkstra transcription is the classic-paper sleeper with the heaviest engagement of the mid-ranked items.
Artifact: saved to Data table hn_top5 — 8 rows, columns rank, title, points, comments, link, hn_discussion, takeaway, collected_at, deduplicated by link (the table already existed from an earlier collection, so 5 rows were refreshed and 3 inserted). Export to Excel is available from the Data tab.
Caveat: HN ranks shift continuously; points/comments are a snapshot at 17:06 and may have moved since.