frontpage.
newsnewestaskshowjobs

Open Source @Github

fp.

WallHop – 12ft.io is gone, so I built a replacement

https://wallhop.io/
145•TheWaffleHax•2h ago•65 comments

Build your own decision model

https://nishtahir.com/build-your-own-decision-model/
159•softwaredoug•4h ago•31 comments

500B Tokens Later: Letting AI Agents Decompile a First-Person Shooter

https://momo5502.com/posts/2026-10-09-game-decompilation/
49•davikr•1h ago•30 comments

2D Vehicles

https://patkerr.co.uk/2d-vehicles/
382•Michelangelo11•3d ago•85 comments

A city-building game in which the city would prefer you didn't

https://housing.over.pizza/
221•JumpCrisscross•7h ago•81 comments

PSPi 6 – Raspberry Pi in a PSP

https://github.com/othermod/PSPi-Version-6
28•therepanic•2h ago•4 comments

The Lightbulb Computer

https://lightbulbcomputer.com/
290•oskarth•23h ago•45 comments

Veda: The First Agentic Hobby Operating System

https://github.com/vahmoh25/Veda
32•vahmohh•3h ago•3 comments

Nix wrote half of my debugger

https://fzakaria.com/2026/10/07/nix-wrote-half-of-my-debugger
154•ingve•1d ago•28 comments

Show HN: Happy Hangul Day! An RNN for Generating Korean Handwriting Strokes

https://hangul.ink/blog/hangul-day
14•jbaudanza•1d ago•2 comments

Knuth reward check

https://www.thomas-huehn.com/knuth-reward-check/
162•Curiositry•11h ago•61 comments

Why DuckDB 2.0 is faster

https://motherduck.com/blog/why-duckdb-20-is-faster/
164•tosh•9h ago•51 comments

Five months treating bugs like patients and coding agents like a medical team

https://www.cockroachlabs.com/blog/experiment-running-hospital-code/
87•rafiss•1d ago•36 comments

Talorys – A self-hosted personal AI agent on Cloudflare's free tier

https://github.com/rociiu/talorys
262•rociiu•16h ago•123 comments

Mxc: Microsoft Execution Containers version 1.0.0

https://blogs.windows.com/windowsdeveloper/2026/10/07/microsoft-execution-containers-policy-drive...
171•smokel•1d ago•39 comments

Unikernels were hard. key word: were

https://ghuntley.com/unikernels/
117•ghuntley•13h ago•50 comments

Retrofitting language models to operate over bytes

https://www.nature.com/articles/s41586-026-11111-4
19•theanonymousone•3d ago•0 comments

OpenSCAD the Programmers Solid 3D CAD Modeller

https://openscad.org/
117•b-man•4d ago•92 comments

Grieving the loss of details

https://purplesyringa.moe/blog/grieving-the-loss-of-details/
371•signa11•4d ago•288 comments

Getting old Macromedia Director Games to run on modern Hardware

https://werwolv.net/posts/macromedia_copy_protection/
51•speckx•1d ago•7 comments

Show HN: Diffle, a keyboard-centric diff viewer with LSP support

https://github.com/moritzwilksch/diffle
18•mwil1000•2d ago•1 comments

Rampart: Browser native on-device PII radaction

https://ndstudio.gov/posts/say-hello-to-rampart
81•nateb2022•1d ago•30 comments

Nvidia in talks to acquire US 'open' model startup Reflection AI

https://www.ft.com/content/052610c5-22b4-4dd4-932e-b7f9f0628b6a
134•arkj•8h ago•91 comments

C for Rust programmers

https://bd103.dev/blog/2026-10-07-c-for-rust-programmers/
120•xyproto•2d ago•107 comments

Food processing influences metabolism and brain activity

https://news.vt.edu/articles/2026/10/research_fralinbiomed_upfhutelin.html
118•gmays•22h ago•90 comments

Eye of Sauron: Long-Range Hidden Spy Camera Detection (2024)

https://www.usenix.org/conference/usenixsecurity24/presentation/zhang-qibo
320•ortusdux•3d ago•76 comments

Recent AI models struggled to match a human algorithmic innovation

https://epoch.ai/publications/innovationeval
82•merksittich•1d ago•63 comments

Telegram Desktop vulnerability allowed any user's file to be stolen

https://beaksec.github.io/posts/telegram-desktop-one-click-account-takeover/
431•g-b-r•1d ago•276 comments

Chernobyl particles reveal unexpectedly stable nuclear fuel after 40 years

https://phys.org/news/2026-10-chernobyl-particles-reveal-unexpectedly-stable.html
143•geox•4d ago•55 comments

I would like the value of my home to rise, while my property taxes fall

https://conversableeconomist.com/2026/09/28/i-would-like-the-value-of-my-home-to-rise-while-my-pr...
228•colinprince•14h ago•526 comments
Open in hackernews

500B Tokens Later: Letting AI Agents Decompile a First-Person Shooter

https://momo5502.com/posts/2026-10-09-game-decompilation/
49•davikr•1h ago

Comments

WillAdams•1h ago
To save folks looking this up:

>At current 2026 API rates, 500 billion AI tokens would cost roughly $100,000–$750,000 depending on the model, with most flagship models in the $150–$400 per million input tokens range

Gigachad•55m ago
This stuff is all done on highly subsidized subscription plans. I suspect Antropic is quite happy to sell these people $100k of compute for $4k because it boosts their growth numbers and they can tell investors once they stop subsidizing, this will grow to $100k. Despite the fact that most of this stuff simply wouldn't be done without the subsidization.
chii•36m ago
the exact same arguments were said about uber's business at the start.

Yet, it is now profitable.

The bet is that people realize how valuable these services are, and despite complaining, they still would pay the higher price. This realization would not happen without this initial subsidy from investors.

It isn't too different from drug dealer's first sample free...

thway15269037•33m ago
Uber business model wasn't a subscription "for 10 bucks you can travel 900 lightyears a week"
Gigachad•19m ago
There’s also examples where this didn’t work. Moviepass for example.

Taxis were an established profitable business model and the uber subsidisation wasn’t anywhere near as much as AI subsidies.

isubkhankulov•5m ago
Disagree with your second paragraph. Uber/lyft subsidized into deep negative margin territory around ~2015 or so. Anthropic (and OpenAI) are subsidizing but not losing money on these consumer plans.
j2kun•54m ago
I struggle to believe that someone would find it worth that much money to have a decompiled version of a game they also commit to keeping private.
girvo•47m ago
> they also commit to keeping private

Reading between the lines:

"The avid reader of my blog might have noticed that I had previously written two posts that have since been removed. Everyone else might now be wondering which game I am talking about. To both of you I can only say that corporate America was here to ruin our fun."

Keeping it private likely wasn't the original plan...

TomatoCo•53m ago
Where are you getting 150-400 per million input?

https://developers.openai.com/api/docs/pricing https://platform.claude.com/docs/en/about-claude/pricing

OpenAI and Anthropic are both 10/mil in.

https://openrouter.ai/z-ai/glm-5.3#providers https://openrouter.ai/moonshotai/kimi-k3#providers Other frontier models are like 1-3/mil in.

Also, 500 billion is 500,000 millions. At the lower end of your 140/mil estimate that's 70 million dollars. Even at my 2/mil lookup for Chinese frontier models that's one million. Show your math for 100k-750k, please.

WillAdams•9m ago
It was a search for "average cost of 500 billion ai tokens" which may or may not have been the correct phrasing, but seemed straight-forward enough that at first blush, accepting the AI-generated answer seemed reasonable.
GaggiX•35m ago
The vast majority of these tokens are cache input tokens so even at API price the cost would be much lower.
thway15269037•13m ago
Even with 95% cache hit, and on cheapest chinese model, it would still be in tens of thousands of dollars (I assume that of 500B tokens at least 10B would be in "output"). If we switch gears to Kimi K* then if would very quickly escalate in hundred thousands USD.
brandonpelfrey•59m ago
Unless you explicitly need byte-matching decompilation, there are significantly faster ways to produce a decompilation/C which is functionally equivalent. I need to post about this. What's been working for me is that for every function, Agent A is tasked with writing some code which is semantically equivalent to the original assembly, but not necessarily exactly the same. Agent A also writes tests. Agent A submits the implementation of the function and tests to the harness for it to judge. The harness runs both the original function and the submitted function in a virtual machine/simulator/emulator (the tests define function inputs and starting state). The harness will only accept the implementation if 1) the read/write sequence to RAM is identical to the original function's, and 2) there must be complete line and branch coverage of the original function being decompiled.

I've found this to be robust for decompiling games, while giving the agents enough freedom to write code that is readable and not waste a ton of time making sure e.g. instruction ordering, register assignments, etc. are all exactly the same. For me, having byte-matching decompilation is only one way to produce a decompilation I know is faithful to the original. This "high-level decompilation" process I just described is something agents can do much more quickly.

j2kun•57m ago
Functional equivalence here, of course, depends on the completeness of the test suite, where byte-identical compiled artifacts does not.

(For example, your approach would not necessarily catch all the same overflow behaviors; the OP expressly claimed that "replicating all bugs" was also important, and many bugs are caused by certain overflow behaviors)

SubiculumCode•55m ago
Byte exact seems only of interest to preserve known bugs etc for cheats/shortcuts/etc.
j2kun•51m ago
thway15269037•37m ago
I struggle to understand what legal leverage they used to threaten him to remove every detail about the game. Can someone post the game name and company name?

So, if you reverse-engineer game X and post reverse-engineered code, what exactly do you infringe, how and in which jurisdiction? What changes if it is done via LLM?

(I understand that LLM decompilation is absolutely out of hand right now and something surely will come to trample the fun. But what and when? I suppose american LLMs will have their system prompt updated to forbid any reversing help and report suspicious activity straight to legal hotline)

xnx•30m ago
Call of Duty: Modern Warfare 2 (2009) (from a previous version of the page)
georgemcbay•35m ago
In case anyone is curious about the obvious question of which game they are talking about... based on months-old reddit posts (which seem like links to prior progress reports of the same project) the game in question appears to be Call of Duty: Modern Warfare 2 (the original 2009 version).

https://www.reddit.com/r/ReverseEngineering/comments/1vxig19...

xnx•33m ago
A previous version of the page said the game was Call of Duty: Modern Warfare 2 (2009).
WheelsAtLarge•22m ago
Interesting, if all software can be decompiled and copied what is the future of software. Will all software be SaaS? A time where the majority of PCs will be terminals? Game consoles are almost there. It's only a small jump for all software to go that way.
Daishiman•14m ago
Most software organizations pay for is effectively a SaaS or something where software is a minor part of the artifact and support is where the real money is.
aetherspawn•20m ago
The reason this cost so much is because the AI has the ridiculous goal of getting identical assembly output.

The agents would have had to mess around with compiler versions, optimisation options, and the phase of the moon as well.

If you just went for functional equivalence, it would probably cost 10x or 100x less tokens.

Another false economy was using Sonnet instead of a more intelligent model like Sol 6.1 (1), which would have cost more per token, but is 100x or so better at reverse engineering and coding and therefore can chew through the source code much quicker and make fewer mistakes, meaning less work needing to be scrapped.

In my testing doing a similar task, I ran multiple sonnet for weeks and burnt through ~$1000 in tokens to get 20% completion and output that was pretty bad. After switching to Sol 6.1, it finished the whole task in around 2 days, cost around $50, and it did it with zero supervision and a single /goal.

(1): struggle to use Opus for reverse engineering, too many safeguards. OAI has virtually none, and uses way less tokens so is more economical.

Gigachad•14m ago
Identical output isn’t ridiculous. It’s pretty much a requirement to ensure the game actually is the same in every way. These decomp projects are pitched as a high performance alternative to emulation.

No one is going to use it if it’s a kind of close but not really reimplementation.

Testing functional equivalence is also pretty much impossible. How would you for example test the new one has exactly the same bugs which haven’t been discovered yet. Or doesn’t introduce new ones? This stuff matters for speed runners.

aetherspawn•7m ago
It’s ridiculous because something as simple as the compiler picking different registers is going to make zero functional difference but give a false negative on assembly compare.

Yet the C code can’t pick what registers to use, so the poor agent is probably shuffling the code around randomly for hours or days until it matches.

That’s probably why the agent dropped down into inline assembly in the first place (the author complained about this), because I bet it’s thinking trace was that this is futile.

Compilers themselves are not even deterministic and running them with different -j thread counts makes different assembly.

vivzkestrel•10m ago
- i want to very very badly see a post of this using LM studio and one of the open source models

- please someone do it

esafak•9m ago
Can anyone think of any lessons to draw from this for normal development, where we don't have oracles to serve as guardrails? I write specs but the agents still find ways to insert bugs between the lines. Oh well, job security.
That may be true, but I hate it when people repeat the false idea that functional equivalence requires only a test suite that has full branch/line coverage. Call me triggered :)

That said, I would probably follow this same approach if I were to do this, but with extensive randomized testing as well.

hedgehog•12m ago
You can do the process in stages. Do the first decompilation mechanically (no LLM), use a SMT solver to show it builds to an equivalent binary to the original, and then use LLM to clean up the code into something idiomatic with the benefit of a correct binary built with the new toolchain. This helps when you want to port across languages or toolchains, and helps protect against toolchain bugs.
SubiculumCode•56m ago
So you restricted it to implementing the same function (same inputs,outputs, dependencies as original?) and prevented the agents from making design decisions by keeping it's scope restricted?
brandonpelfrey•28m ago
Yes. It can gain more context, but this has been enough. Note, there is also a notion of adversarial review layered on top in which it tries to poke holes in the test plan "you didn't handle this case of XYZ". It isn't actually perfect as a parallel thread said it may miss things like wrapping behaviors. In practice, it's very effective.