[derefr]

A "fantasy [retro game] console" is an abstract machine (like the JVM is an abstract machine, or like the Flash runtime is an abstract machine, or like BASIC is an abstract machine) with two key properties:

1. it's compute-resource-constrained — so you can't just transpile DOOM into the "fantasy console's" native programming language / bytecode ISA and expect it to run well, but instead have to learn to program directly for the console's native programming language or ISA — close to the (abstract) metal — to do anything of note with it;

2. it exposes low-level "primitive" features in its native programming language / bytecode ISA, in the form of system calls or MMIO registers, to accelerate graphics/sound operations without consuming (abstract) CPU cycles; thus allowing games developed for the console to run well at 30/60FPS, despite the resource constraints. Where usually these calls are themselves constrained to only allow for "retro"-style output (e.g. allowing audio only in the form of a set number of square-wave frequency channels.)

In other words, a "fantasy [retro game] console" attempts to achieve a similar set of "artistic constraints" for game development that you get from developing for a real retro game console, like the NES or Gameboy. Except that the artistic constraints imposed by fantasy consoles are usually not low-level technical constraints in the system's (theoretical) microarchitecture, but rather arbitrary policy-based constraints imposed by the abstract-machine standard on conforming implementations, and therefore are often less frustrating things to be worked around (think: memory bank switching), and instead are more inspiring constraints to be embraced to fuel the creative process when making a game (think: limited color palette per art asset.)

Or you can think of it like this: what if the Super Nintendo never existed, but there still ended up being "SNES emulators" that all agreed on how they should interpret/run "SNES ROMs" — all implementations of a shared abstract-machine standard? Developers would then be producing "SNES games" not to run on a physical SNES, but instead solely so that you could then run them on a compatible emulator. Although, in theory, nothing would stop someone from making a real hardware SNES conforming to the abstract-machine standard — and then SNES ROMs would work on it as well. That's a "fantasy console."

For a given fantasy console, there may or may not be any physical-hardware implementations; though usually there aren't. A well-known example of a "fantasy console" with only virtual implementations (i.e. emulators) is the PICO-8 (https://www.lexaloffle.com/pico-8.php). While there are hardware devices that present themselves "as" a PICO-8 "console", they do this by using some other ISA to run a full OS kernel, which then launches into a userland PICO-8 emulator. There is no hardware device whose CPU+BIOS enables it to natively execute PICO-8 code. (It's the difference between a NES Classic, and an actual NES.)

Meanwhile, this thing — the uConsole — isn't a "fantasy console" itself, per se (i.e. they're using the term wrong), but rather a device focused on running multiple fantasy-console emulators, which therefore doesn't even attempt to present itself as being any particular "fantasy console's" hardware. It's basically just one of the many "retro handheld" devices out of Shenzhen recently (which often ship with fantasy-console emulators) — except this one's got a keyboard! :P

A fun example of a more true hardware "fantasy console", where the hardware is itself an implementation of a particular fantasy-console abstract machine (and where the abstract-machine standard and the hardware implementation were co-developed to make this possible), is the https://www.commanderx16.com/ — which is both a fantasy-console in its full capabilities, but is also a backward-compatible superset of the abstract-machine model of a Commodore 64, and so compatible with Commodore 64 software/games (so this abstract-machine can also be thought of as an "enhanced" Commodore 64 — like how the Gameboy Color was an "enhanced" Gameboy — making "enhanced ports" of Commodore 64 games an especially easy/interesting project.)

[unwind]

I don't think you are correct about the X16, it is not that compatible with the C64. From their FAQ [1]:

Although it runs Commodore BASIC (itself based on Microsoft BASIC as many machines were) it was never intended to be an "emulator" or compatible with the C64 or any other machine. It is its own machine, just as the ZX Spectrum, Atari 800, etc. were also distinct from the C64. [...] Ultimately C64 compatibility is not the aim of this product.

[1]: https://www.commanderx16.com/forum/index.php?/about-faq/

[jhbadger]

Just a minor point -- the Commander X16 isn't actually compatible with the Commodore 64 -- it's kind of like a fantasy version of what the Commodore 64 could have evolved into if they had stayed with that rather than shifting to the Amiga. It's "Kernal" compatible with the Commodore 64, Vic 20, and PET, meaning that developing for the platform should feel comfortable to programmers of those machines but it can't just run software for those machines unported.

[Version467]

That's fascinating. Thanks for giving such an in-depth explanation. Doesn't appeal to me at all, but I can totally see why people find these constraints interesting. Especially considering that some of the all-time greatest games were developed on similarly constrained hardware.

[evolve2k]

Can someone point to a few popular games in this, err Genre? Sounds fascinating.

[TillE]

> it's compute-resource-constrained

I guess the PICO-8 has some kind of CPU limit, but it's orders of magnitude over the 8-bit 6502 consoles it's broadly mimicking. That was sort of disappointing to me.

[derefr]

I believe that, rather than a CPU usage limit (which would require some kind of CPU-cycle accounting tracking, which would impose a high overhead on a system that's based on high-level source-code interpretation rather than on a bytecode virtual machine), the PICO-8 chose instead to go the route of limiting code complexity by just limiting (Lua source) code size. So your code can go as fast as you like — you just can't have very much of it. Which seems to result in practice in games that have similar features and play-styles to retro-games, despite the constraint coming from a different direction.

Like I said: fantasy-console abstract machines don't aim for technical limitations; but rather, for stylistic limitations. They don't want to impose upon you low-level technical barriers, for you to just treat those limitations as implementation-time programming puzzles to be overcome or worked around. (If you want that, just write games for an actual retro console!) Rather, they want to impose high-level constraints that influence your design-time choices. Less like typing on a broken keyboard; more like writing a poem with constrained rhyme-scheme and meter.

That's why these are "fantasy" consoles — their particular lack of technical constraints means that they can actually require a decent modern CPU/GPU/etc to run; and so could never have actually existed in the era they borrow their aesthetics from.

[chrisallenlane]

> So your code can go as fast as you like

I've been working on an (IMO) sophisticated tactical game with strong AI in Pico-8 for just about two years now, and I can say that this is not true.

> which would require some kind of CPU-cycle accounting tracking

This is pretty much what it does.

Pico-8 tracks an arbitrary "cycle" budget, which is used to calculate how much computation you're allowed to perform per frame. You're absolutely not going to compute at "bare metal" speed.

Here's some info in the (community) docs:

https://pico-8.fandom.com/wiki/CPU

I don't know how this does/does not compare to the 6502, because I unfortunately don't have any experience there. But you're absolutely not going to get bare-metal performance inside of Pico-8.

You're right about limiting code-size, though. For my own project, the code size limits have proven far more difficult to work around than the performance limits.

Tangent now, but these are some of the Pico-8 limitations:

- screen is 128x128 pixels

- only 16 colors are available (sort of... there's a "hidden palette" too)

- cartridge size may not exceed 32 kb

- cartridge may not exceed 65k characters

- Lua AST may not exceed 8192 tokens

That last one has been the hardest constraint for me to manage, by far.

Anyway, Pico-8 is a ton of fun. Try it out if you're inclined :)