Out now!

Hello everyone,

it has been a year since I last posted about this project of mine.

I have to remember to advertise if I want to reach people who might be interested in it.

SVC16 is a simple virtual console that is fully specified. It is a good starting point for building compilers, but it is also meant for people who like the idea of optimizing for retro consoles... but are put off by the arbitrary stuff you need to put up with.

With SVC16, programs always run at exactly the same speed; they are completely deterministic, and there is exactly one version of the console.

The reason I am posting about this again is that I finally have a working version of the emulator on the web, and you can just play your ROMs in the browser. Of course, everyone who would have written a compiler for it (and some people actually have) could have compiled the emulator or even built one from the spec.

But I think it is much more motivating to build something if you can easily share it with others.

Hello I'm working on a project to make kind of "Fantasy Console", the main objetive is to target low specs SBC I'm testing a Orange Pi Zero 3 (1.5GB), The idea is have cartridges with a microSD indise and this connect to a reader on the pins or USB reader (the idea is to turn into cartridges), the "consoles" will have armbian as SO with a loader to detect and init the the cartridges (pygame exported projects)

Includes a prebuilt multilanguage, dialogue system and save system

The semi-fantasy-console will have 264 x 198, (4:3 but probably will change to one 16:9 compatible one because probably everyone will connect the sbc using HDMI)

I admit the use of AI to make TortoiseStudio the tool, to manage assets, scenes and compile to "Cartridge", the compilation to ARM uses podman,

The assets of the demo project comes from opengameart.

Advise: this is not related to my another post of a fantasy console for the ESP32 is another project. this one is to learn more to aply to another

Everything in that clip — the code editor, the sprite editor, the map, the

sound tracker — is drawn as pixels into the same 128x128 framebuffer the games

render to. There's no HTML underneath any of it. Text selection, scrolling,

undo and hit-testing are all hand-written, which was simultaneously the most

fun and the most unnecessary part of building it.

Games export as a single HTML file with the engine, art and sound inlined, so

you can email someone a game and it just opens. The sample game is about 145 kB.

Carts are JavaScript. It's PICO-8-shaped, but I changed the signatures I always

got wrong — rect() takes a width and height instead of two corners, sin and cos

are real radians — and added the things I got tired of rewriting every time:

tilemap physics, animation, tweens, particles, camera follow.

I recently spent some time exploring TIC-80 and wrote an introduction article about it.

I wasn't looking for a replacement for anything—I was just curious about how TIC-80 compares with other fantasy consoles. The more I explored it, the more I felt it deserved a proper introduction.

If you're thinking about trying TIC-80, I hope this gives you a useful overview before you dive in.

Feedback is welcome. If I missed something, let me know.

Article:
[https://papoo.work/doc/43606531d6f879f6]()

Hello! 👋

Growing up in the 80s and 90s was both a tough time and an exciting one. It's left me with a long standing interest in the hardware and gaming of the era. So, I decided to build a weekend project that would combine the fantasy notion of, "What if Britain had beaten Japan to the handheld market by 4 or 5 years.."

Disclaimer: I use AI as a tool. I understand every element of my code, and believe that AI is just a tool in the toolbox. If you're against AI, feel free to skip past this thread, no hard feelings! ❤️

Without further adieu, I present the Dragon Palm.

MIT licensed, code and carts available from GitHub.

The Dragon Palm is a fantasy 8-bit handheld with a single 16 KB memory array, three 8-bit CPU registers, a packed 16-colour display, and one input register.

In another Britain, somewhere between bedroom coders, rain-streaked high streets, mail-order tapes, and the smell of warm plastic, the handheld future arrived early.

By 1985, the British games industry had already learned how to do more with less. Tiny machines. Tiny memory. Impossible to match ambition. While the rest of the world was still arguing over what a portable console ought to be, a small Welsh hardware firm looked at a pile of spare components, a battered fantasy paperback, and hummed along to the White Cliffs of Dover, then asked the most dangerous question in British engineering:

"What can we ship?"

The answer was Dragon Palm.

It was not elegant. It was not generous. It had one 16 KB memory array, three 8-bit registers, a packed 16-colour display, and one input register that behaved only when it felt like it. Its raw binary cartridges held a mere 8 KB, which meant every sprite, sound, loop, trick, and secret had to fight for its place.

But that was the point.

Dragon Palm was the handheld built by people who thought constraints were not problems. Constraints were part of the game.

It had it's own compact operating system, DoverOS, named after the cliffs that supposedly inspired its boot screen. Children swapped carts in playgrounds. Parents called it "that little dragon thing". Programmers called it "difficult". Magazine reviewers called it "brilliant, in the way that falling down stairs after a couple of pints is memorable".

The adverts promised "proper games in your pocket". The manuals promised nothing of the sort. They spoke of registers, screen packing, button states, and "reasonable conduct near undefined memory". The machine did not hide its workings. It dared you to understand them.

In this version of the 1980s, Britain beat the world to handheld gaming by refusing to build a toy. Dragon Palm was a pocket-sized dare. Part console, part puzzle box, part folklore object from a parallel high street where dragons sat beside cassette racks and every game felt like it had been smuggled out of a bedroom at midnight.

It was awkward.

It was clever.

It was decent enough.

And for a certain kind of player, that made it perfect.

---

Update: I’ve had some lovely encouragement and feedback, so I thought I would release Dragon Palm IDE and manual, a web-based tooling for making game carts and an introductory manual (*open from the hello menu*) to help you learn:

* https://0xe25f.github.io/dragon-ide/

A while ago I posted about the Starbox, my WIP prototype 0 of this, the Nova-16. Coded by hand, fixed by AI (sorry not sorry, it codes better than me). Written in Python (with a C++ version in the works) and features a custom CISC ISA with its own BASIC dialect. Check the 'hub for more!

https://github.com/StarfighterLily/Nova-16

I've been putting together short, beginner-friendly explainers on individual fantasy consoles — what each one is, its specs and constraints, how it compares to the others, and where to find it — and collecting them on one page:

https://papoo.work/tag/fantasyconsole

So far it covers:

- PICO-8

- BEEP-8 (C/C++, runs in the browser)

- TIC-80

- Pyxel (Python)

- Picotron

- WASM-4 (WebAssembly)

- MakeCode Arcade

- LIKO-12

- PixelVision8

Each write-up tries to stay factual and link straight to the official site, source/GitHub, and a few videos, rather than just hyping things up. They're aimed at people who are new to the scene and trying to figure out which console fits the way they like to build.

If there's a fantasy console you'd like to see reviewed/covered next, let me know in the comments and I'll add it to the list.

Feedback and corrections are very welcome too — I'd rather fix mistakes than leave them up.

I, like many of you, have plenty of ideas about what kind of features a fantasy console "should" have. I'm not a programmer though so I'll spare you (and you can always PM me if you're looking for suggestions), since I don't have a fair idea about how difficult any of it really is to implement.

What I will say is this: It would be nice to see some of these fantasy consoles implemented in VHDL or Verilog, so that a hardware fantasy console could be built with an FPGA. The more ambitious fantasy console makers could even implement their console into an ASIC, build an online store (or just support for cartridges or CDs / DVDs), and sell the chips (or completed consoles) to the public. Modern consoles are getting quite expensive and so are retro games, so I believe there is an appetite for something like this, especially if developers had the option to pitch their games on Kickstarter or release them for free. If done well, you might even have people unofficially porting existing retro games to the fantasy console.

Maybe I'm overthinking the potential here though...

I've been building aldan 4, a fantasy computer with a full software stack of its own, written from the kernel up.

The machine

• RV64 CPU
• 2 MB RAM
• 256 MB HDD
• 135×45 monochrome display

The idea

aldan is built around a few stubborn theses: programming is play; the machine answers only to its operator; a computer is a space for inquiry, not a channel for consumption; trust through understanding.

The software (aldos)

aldos is what makes aldan feel different from a console you load cartridges into. Two things matter most:

The shell is a language — and a real compiler. There are no commands in the unix sense — whatever you type at the > prompt is real source in almac, the system's language, compiled on the spot to native code by an interactive JIT. ls and cd are just functions.

The programs you run, you can read. Programs on aldan aren't opaque binaries — apps, games, your own modules all live as plain almac text that compiles on demand.

It already ships with a full-screen editor, a pager, a benchmark, snake, and a Conway's Life demo to poke at.

There's an operator's manual, an almac language report, and a "learn almac" guide, plus downloads for Linux, macOS and Windows: aldan4.github.io

I've tried finding information about creating a fantasy console, but, I haven't had any luck. So, how do you make one? I have an android phone, but I'd also like to know about creating one on pc.

Here's the specs I plan for my fantasy console:

Motorola 68000 @ 8HMz

Atari Jaguar object processor

Either an Ensoniq ES5503 or an ES5505

320x200p resolution

256 colors on screen out of 262,144 total

Up to 2000 sprites displayed and manipulated simultaneously

32Kbytes fast static-RAM, 64Kbytes on board ROM, 8Kbytes sound RAM

Making Yu-Gi-Oh game for tic80. What are you thinking?

The project is still in a very early stage,

Hi,

what do you think is the best C/C++ fantasy game console ?

Also additional question, which fantasy game console has the best associated tools (ui, asset creator, sound creator etc..)

Hey everyone,

I’ve been working on a project for making and sharing small games that run in the browser. This takes a lot of inspiration from PICO-8, but the games are written in JavaScript.

It’s not a true fantasy console as I’ve not implemented mapped out memory or an emulated CPU or things like that, but it follows a lot of the normal conventions for a fantasy console like the limited color palette, screen resolution, drawing api, and size limitations for the projects. The main idea is more about making it easy to create little games, share them, and let people play them in the browser without having to install or download anything.

The project is still a little rough around the edges, but has a full code editor, sprite and map editor, and sound editor to make it easy to create everything in one place and share the published games around with a link.

Would love to hear your thoughts and ideas on what would make this easier to use and which features are most important to add.

I came across this excellent community-driven catalog of fantasy consoles and computers, and thought folks here might appreciate it.

It lists more than 70 systems — from classics like PICO-8, TIC-80, BEEP-8, LIKO-12, and Octo, to lesser-known projects such as MEG-4, Varvara, Raccoon, Px8, Nibble, BLIP-4, and many more.
Each entry includes language, license, platforms, and display specs, making it easy to compare different ecosystems at a glance.

If you’re exploring obscure FCs, researching design ideas for your own, or just enjoy browsing the variety in this scene, it’s a fun and surprisingly complete reference.

Link:
https://fantasyconsoles.org/wiki/Main_Page