Top
Best
New

Posted by snoofydude 15 hours ago

This game is a single 13 KiB file that runs on Windows, Linux and in the Browser(iczelia.net)
242 points | 65 comments
TuringNYC 14 hours ago|
On a related note -- when I see the minuscule filesize of the original Zelda game on emulators, I marvel at how little text/code/information could produce how much wonder, how far-reaching impact, and how many hours of enchantment for me.

https://en.wikipedia.org/wiki/The_Legend_of_Zelda_(video_gam...

erwincoumans 7 hours ago||
Indeed, magic. How about the Commodore 64, there was a game (Eindeloos, Radarsoft, 1985) within 64kb that has a huge map. Someone recently (after 40 years!) extracted the map (500 screens) and the png alone is 800kb. See the story an zoom in and try finding the little heart in the map! https://adayinthelifeof.nl/2025/03/07/endless.html
ErroneousBosh 4 hours ago|||
Elite on the BBC Micro - which had 32kB of RAM, a huge chunk of which was required for the screen - managed to have eight galaxies with 256 distinct planets each.

Everything about them was procedurally generated, even the names, which required some clever code to ensure none of them used rude words.

dspillett 54 minutes ago||
> which had 32kB of RAM, a huge chunk of which was required for the screen

People assume 10KB, with the BBC Micro¹² version's version using a mix of modes 4 & 5 (320×256×1bbp and 160×256×2bbp respectively), but as well as the split screen trickery they tweaked the graphics hardware in more detail than that to create custom modes. There were only 248 scanlines and either 256 or 128 pixels per line, so the display took 7.75KB. As well as leaving more memory for the rest of the code, this reduced the amount being drawn, so helped keep the draw speed acceptable.

This left about 24KB⁴ for the rest of the code and its working data. Still a very impressive feat!

> - managed to have eight galaxies with 256 distinct planets each.

IIRC it was originally going to be larger than that, they toned it down a bit but not due to technical limitations (the galaxy generator code would not have needed to be any larger).

--------

[1] The Electron lacked support that allowed the split screen to work (one of the chips removed meant the required timing signal wasn't available), so it was all monochrome though still with the custom resolution and taking 7.75KB.

[2] The version enhanced for the Master series use a mix of mode 1 and mode 2 to enable more colours, 2bbp for the view of space and 4bbp³ for the dashboard. This still used the custom resolution, so took 15.5KB rather than 20KB. This was achieved by using the shadow RAM bank to host the screen display (some programs instead used this feature to implement double-buffering for smoother screen drawing), allowing the screen to take twice as much space while also freeing up memory to hold things that would have been loaded from disc when needed⁵ in the Micro version.

[3] Actually effectively 3bbp as the BBC hardware did 8 colours and flashing variants instead of 16 colours (which most other systems used to provide two shades of 8 colours, using the 4th bit as an intensity flag).

[4] less a few chunks here & there needed by code in system ROMs when doing things like reading extra data from the floppy

[5] There were two chunks of code, one for in-flight and one for while docked, that were swapped in as you entered or left a space station. On the Micro these were pulled from disk each time, on the Master they could both be in RAM. If playing from cassette you had a cut-down version of the game that didn't need this split.

avadodin 4 hours ago|||
that is a legitimate post by itself
jsheard 13 hours ago|||
Zelda 1 was 128 kB, for those wondering, and that's without any compression. Double that for the sequel.
rlv-dan 7 hours ago|||
> without any compression

Perhaps not compression as we see it today. But one could argue that tile based graphics and code based music is a form of compression. Old games used a myriad of cool tricks to get around their limitations.

6510 1 hour ago|||
Modern coders will probably never experience the fun of rewriting the same thing endlessly only to discover how good some early version really was. Then some time after giving up someone else would make a similar thing go 20 times faster.
Drakim 1 hour ago||||
Zelda 1 has TONS of built-in compression, and it's own decompression routines.
jsheard 59 minutes ago||
I should have worded that better, I meant no UPX-style end-to-end compression like the OPs project used. NES games had to be much more judicious than that since there wasn't nearly enough RAM to decompress everything at once.
Andrex 12 hours ago|||
That honestly doesn't seem too bad. Zelda 1 is relatively large but it reuses a lot of assets and honestly probably doesn't have that much text. (More than a Mario but way less than a Dragon Warrior.)
3RTB297 8 hours ago||
My favorite slight of hand was that all the dungeons and caves were part of a single rectangular map. Designers carved out a few specific designs, then other levels were clearly what worked with the remaining map screens available so it all fit in the space they had, with caves thrown in to take up single screen gaps.

https://ian-albert.com/games/legend_of_zelda_maps/

Morizero 7 hours ago||
And created them in somewhat recognizable shapes, e.g. eagle
wasmperson 11 hours ago||
I extracted the linux executable and was surprised to find that both readelf and objdump choke on it despite it loading and running correctly. Some investigation reveals that the name of the dynamic linker was shoved into the "unused" fields in the PT_DYNAMIC header entry to save space:

  Program Headers:
    Type           Offset             VirtAddr           PhysAddr
                   FileSiz            MemSiz              Flags  Align
    INTERP         0x0000000000000088 0x0000000000010088 0x0000000000010088
                   0x000000000000001c 0x000000000000001c         0x0
        [Requesting program interpreter: /lib64/ld-linux-x86-64.so.2]
    DYNAMIC        0x00000000000000e0 0x00000000000100e0 0x6c2f343662696c2f  <-- "/lib64/ld-linux-x86-64.so.2"
                   0x2d78756e696c2d64 0x732e34362d363878         0x322e6f
  readelf: Error: the dynamic segment offset + size exceeds the size of the file
    LOAD           0x0000000000000000 0x0000000000010000 0x0000000000000000
                   0x0000000000001dc0 0x0000000000005660  RWE    0x1000

Two questions:

1. Was this done manually or is there a tool you're using which does this? I see other size-reduction tricks in here as well.

2. Does anybody know of a tool for examining executables which doesn't crap out on binaries like this?

saidnooneever 5 hours ago||
ndisasm can help read it and hex editor. no tools should mangle such format, its useless savings, worth nothing. it will cause problem with AV and other things potentially.

saw some comments about DEP on windows and this and honestly i wouldnt touch this thing with a 10ft stick. if the creator want ppl to play it they can provide a normal binary. not some obfuscated mess.

oguz-ismail2 10 hours ago||
Choke how? Both work fine here
zamadatix 15 hours ago||
For me:

- Browser: works after renaming to .html

- Linux: "./snake.com: line 20: lzma: command not found". Installing the xz package makes it work (already had XWayland enabled so X11 worked, but may be needed if you have a strict Wayland session).

- Windows: As either .com or renaming to .exe I get "The application was unable to start correctly (0xc0000005). Click OK to close the application." Not sure how to make this one work, it's definitely not AV related though (I have that stripped in this sandbox VM).

Edit: Got it working in all 3 now. On Windows I still had DEP enabled on all programs to test some apps earlier, turning that back off allowed it to launch.

w4yai 15 hours ago|||
Works for me on Windows 11
zamadatix 15 hours ago||
Hmm, Windows 11 25H2 here as well. Redbean works so there must be something about this particular approach combined with some unknown setting on my install.

Edit: Got it working, was DEP.

eXpl0it3r 7 hours ago||
What's DEP?
bananaboy 7 hours ago||
Data Execution Prevention https://learn.microsoft.com/en-us/windows/win32/memory/data-...
deklesen 15 hours ago|||
its written in the post
zamadatix 15 hours ago||
If you mean lzma it wasn't immediately apparent to me it was a binary requirement, but inspecting the hex dump at the end + the message is how I figured out it was. I wonder how much space you lose dropping lzma and doing some other method as "tail -c+4294 $0|head -c 5061|lzma -dc>/tmp/a;chmod +x /tmp/a;(/tmp/a&rm /tmp/a);exit" would be more universal and the linux portion isn't all that big.

If you mean the .html rename or whatever my Windows problem was, I must be missing it. Edit: Windows was DEP.

GlumWoodpecker 15 hours ago||
If I ran it with just

    $ chmod +x snake.com
    $ ./snake.com
... then it would try to use Mono to launch it:

    Cannot open assembly './snake.com': File does not contain a valid CIL image.
But, running it explicitly with Bash works:

    $ bash snake.com
Pretty nifty but doesn't work out of the box on any Linux, at least :p Running Debian 13.
seba_dos1 15 hours ago|||
> ... then it would try to use Mono to launch it:

That's because of the binfmt handler that Mono installs which matches the PE header.

MrDrMcCoy 4 hours ago|||
Cosmopolitan libc binaries require a little extra config to work around the defaults most distros set for binfmt: https://justine.lol/apeloader/
Tiereven 1 hour ago||
The fun part is that it's actually 3 executables in a single file. Meaning there is no particular reason it should have the same program on each platform.
nvllsvm 15 hours ago||
Not cross-platform, but I'm reminded of the kkrieger game for Windows which was a 96k FPS game that looked visually impressive for the time.

https://web.archive.org/web/20100304155706/http://www.thepro...

HelloUsername 43 minutes ago||
> kkrieger

Related discussions:

https://news.ycombinator.com/item?id=14409210 (2017)

https://news.ycombinator.com/item?id=37383894 (2023)

https://news.ycombinator.com/item?id=41269079 (2024)

the__alchemist 15 hours ago|||
From that link: Still works on modern PCs! Was able to DL and launch.
rfl890 10 hours ago|||
Not out of the box, though. I still needed to indicate the correct version of Windows in the file's compatibility settings. Windows XP SP3 worked like a charm.
bilegeek 12 hours ago|||
The source code is available as well: https://github.com/jaromil/kkrieger-werkkzeug3
wjbr 6 hours ago||
I've been reminded of this while playing Metroid Prime 4.

I wonder what kinds of modern games we could make with these same ideas.

chii 7 hours ago||
i wonder if such a mechanism could be "enhanced" to produce a true "universal" binary, using a source-to-source compiled language like Haxe?

With Haxe, you can write the application once, target both win32 and linux by compiling to C++ (which then you compile using the platform specific tooling for each paltform), and then target html by compiling to javascript. Then use the same concatenation mechanism and header abuse as described in the article to have all three targets merged into one file that can then be run on all platforms!

k4rnaj1k 2 hours ago|
[dead]
socketcluster 13 hours ago||
I love the idea of applications which exist in one file which you can run anywhere. I've been working towards this with my serverless platform; you can build complex data-driven apps with just one .html file and mostly declarative HTML markup (thanks to web-components which are loaded from a remote server). With modern browser features, you don't need a bundling system. Once you do away with it; a whole universe is opened up.

The ability to load .html files over the file:// protocol is a powerful, often neglected feature. In practice, it means you can double-click an HTML file and it runs an app in your browser instantly.

nottorp 2 hours ago||
> I implemented the game three times in total: once in C for the i686 Visual C platform using WinAPI, once in C for the x86_64 Linux platform using clang and X11, and once in JavaScript for the browser using HTML5 Canvas.

The OP actually wrote two native applications instead of just instantiating a browser.

Retr0id 13 hours ago|||
Sadly a lot of browser features are inaccessible from non-https contexts.
jsheard 13 hours ago|||
Don't most (all?) browsers consider file:// and localhost to be secure for the sake of enabling those features?

https://developer.mozilla.org/en-US/docs/Web/Security/Defens...

mlok 12 hours ago||
Unfortunately, no. CORS will block this on Chrome and Firefox.

https://developer.mozilla.org/en-US/docs/Web/HTTP/Guides/COR...

The security risk : https://www.mozilla.org/en-US/security/advisories/mfsa2019-2...

You need a local webserver. Or bundle everything in one html file.

Am4TIfIsER0ppos 3 hours ago|||
So that's why I have to keep booting a Windows 7 computer in order to use an html file I saved 10+ years ago? Some dumb shit android app.
gabriela_c 11 hours ago|||
or you could use something like caddy (https reverse-proxy, local cert), and have a dedicated ws running in the background that serves your files
billfruit 8 hours ago||
How are you approaching the development of your single file html apps, is there any examples publicly available, sounds very interesting.
trollbridge 15 hours ago||
One of the interesting things about Polyglot is that nobody did it any sooner. It would have been feasible a decade ago or two ago.
Retr0id 13 hours ago|
Now I wonder when the first polyglot file was published. I kinda just assumed they'd been around forever. EICAR.COM comes to mind as a COM/plaintext polyglot
ValdikSS 14 hours ago||
https://js13kgames.com/
nine_k 7 hours ago|
What entertains me most is that the thing contains three independent implementations of a graphics-based game, strung together, wrapped into a crafty multiplatform loader... and it all still takes 13 kiB.
More comments...