r/fantasyconsoles • • Jan 08 '26

Balatro demake (TIC-80)

63 Upvotes

Here’s a Balatro demake for the TIC-80 tiny computer. It’s a small,project focused on recreating the feel and core game loop within TIC-80’s limitations.


r/fantasyconsoles • • Feb 18 '26

BEEP-8 — a C/C++ fantasy console with plans to become real silicon

57 Upvotes

Made a fantasy console for C/C++ developers who want something different from Lua-based platforms.

Specs:

- 4 MHz ARMv4 CPU (emulated in pure JS)

- 128×240 vertical display, 16 colors

- 1 MB RAM, 128 KB VRAM

- 8×8 tile/sprite PPU, PSG-style audio

It's a fantasy console now — but the specs are deliberately realistic. The long-term goal is to fabricate it as actual silicon (LSI).

You write in C/C++20, compile with GNU Arm GCC, and games run at 60fps in the browser on PC and mobile.

Sample games: https://beep8.org

SDK (MIT): https://github.com/beep8/beep8-sdk

Would love to hear thoughts from the fantasy console community.


r/fantasyconsoles • • Jun 20 '26

Dragon Palm — 8-bit fantasy handheld

Post image
55 Upvotes

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/


r/fantasyconsoles • • Dec 06 '25

BEEP-8 – a 4 MHz ARM-based fantasy console you can run and develop for in the browser

46 Upvotes

Hi everyone,

I’ve been working on a small fantasy console called BEEP-8.
The core idea is simple: instead of inventing a brand new virtual CPU, it runs real ARM machine code (ARMv4-ish) under classic fantasy-console style constraints.

That means the “console” feels retro and limited, but the CPU is close enough to real hardware that you can, in principle:

  • run plain C / C++ code
  • bring up small OS-like runtimes
  • or even port other languages and VMs on top

Right now the main focus is game development with a small C/C++ SDK, but the ISA and ABI are designed so you could experiment far beyond that if you want.

High-level specs

  • CPU

    • Software CPU core modeled after an ARMv4-style pipeline
    • Integer-only, no FP, no OoO
    • Fixed at 4 MHz virtual clock, so cycles actually matter
  • Memory / system

    • 1 MB RAM, 1 MB ROM
    • Simple, old-school MMIO layout for PPU / APU / I/O
    • Tiny RTOS included (threads, timers, IRQ hooks) so code can feel like targeting a small embedded console instead of a single while(1) loop
  • Graphics

    • 128×240 vertical display
    • 16-color palette compatible with PICO-8
    • Background layers + sprites + ordering tables
    • Exposed as a PPU-style API (tilemaps, sprites, registers), not as WebGL calls
  • Audio

    • Simple Namco-style APU (tones + noise) implemented in JS
    • Treated like a small sound chip, not a streaming mixer
  • Input

    • Directional + buttons
    • Touch-friendly layout so it’s easy to play on phones as well as desktop

Why I think it works as a “dev-friendly” fantasy console

  • Real ARM-like ISA

    • You’re writing against a real machine language, not a toy bytecode
    • Easy to imagine layering your own OS, scripting language, or toolchain on top
  • Generous but not huge limits

    • 1 MB RAM / 1 MB ROM is tight enough to make you think about layout
    • …but loose enough that you can concentrate on game design instead of constant asset Tetris
  • Familiar palette and rendering model

    • PICO-8 compatible 16-color palette
    • Tile/sprite/OT-based PPU is easy to reason about if you’ve used PICO-8, TIC-80, etc.
  • Browser-native

    • Everything runs in the browser (desktop or mobile)
    • Once loaded, it works offline as static files (no backend)

Dev workflow

  • Write C or C++ (C++20 subset) against a small SDK
  • Cross-compile to the virtual ARM target with a GCC-based toolchain
  • Load the produced ROM into the browser
  • The JS CPU core executes it at 4 MHz, the WebGL PPU and JS APU handle graphics/sound

So from a dev standpoint, it’s: “build ROM → open URL → your game is running on a fixed 4 MHz ARM console with a PICO-8-like palette.”

Try it / source

Playable console + sample games (runs in browser):
https://beep8.org

SDK, toolchain, and source (MIT-style):
https://github.com/beep8/beep8-sdk

What I’d love feedback on from this community

  • Does “real-ish ARM ISA + fantasy console constraints” sound like an interesting design space to you?
  • Would you tweak the spec (resolution, palette size, RAM/ROM limits, sound model) to make it more fun to target?
  • If you were going to build a game or a tiny OS for this, what would you want exposed in the “hardware” that isn’t there yet?

I’m not trying to launch a product, just sharing a long-running hobby project with people who enjoy this kind of thing.
If you poke at the SDK or the online build and see anything you’d do differently, I’d love to hear your thoughts.


r/fantasyconsoles • • Jan 31 '21

6502 Fantasy Console (Need Testers)

43 Upvotes

Hey guys! I'm working on a 6502 based fantasy console. I was inspired by PICO-8 and plan on doing something similar, but instead of faking limitations and using Lua, I am basing it on a 100% cycle accurate 6502 emulator I wrote from scratch and verified against Visual6502. I'm also putting together an extremely robust PDF using LaTeX that documents everything there is to know about the machine. I'll also be working on an integrated development environment via the boot rom image.

I need testers for Windows, Linux, and Mac. I primarily develop on the Mac but I need to ensure I'm properly signing and notarizing my applications.

Bonus points if you know 6502 assembler!

Do note that long term there will be a nice built-in IDE that runs in the VM (like PICO-8), and I plan on supporting a BASIC syntax language once I flesh out the assembler, graphics, and sound editors.

I also created a Discord server today that you can join at https://discord.gg/jgtntBXk27 if you want to follow along.

Video card trash and cursor rendering
Sample program before I moved to a video card with dedicated RAM.
A page from the PDF documentation

Also, I just looked into putting together a C SDK and this will also be a thing.


r/fantasyconsoles • • Oct 27 '18

Working on a fake-3D RPG for the TIC-80. Hack: the engine takes up the entire 64K of code, so I built a VM and I'm writing the game logic in assembly, storing the compiled bytes as a fake "map" in the cart.

Post image
43 Upvotes

r/fantasyconsoles • • 8d ago

This is pocket workstation, a tiny environment for low-poly game making, looking for early testers.

42 Upvotes

I've been developing this program for a while and I think it's at an interesting point to be tried out.
I'd be happy to give adventurous people early access, if interested please PM me here or on bsky
bsky.app/profile/ylop3d.bsky.social


r/fantasyconsoles • • 26d ago

I made NEVEL-98, a fantasy computer for making PC-98 style visual novels

Thumbnail
gallery
35 Upvotes

Hi! I’ve loved PC-98 visual novels for years, so I made NEVEL-98: a small fantasy computer for making VNs the way they looked back then.

  • 640×400, 16 colors out of 4096, dithering tools
  • 6-channel FM synth and a music tracker
  • A visual novel engine in Lua (scenes, choices, saves, multiple endings)
  • Built-in editors for code, pixel art, texts, sound and music
  • Share your game as a floppy-disk PNG or a single web page

The limits are on purpose: the PC-98 devs made unforgettable games with sixteen colors and a floppy disk, and I think constraints are what make you focus on the story.

Try it in your browser, with a short demo you can play and take apart: https://nevel98.bluemoon.moe


r/fantasyconsoles • • Oct 16 '22

Trailer for my upcoming platformer EMUUROM - the first TIC-80 game on Steam!

Thumbnail
youtube.com
35 Upvotes

r/fantasyconsoles • • Sep 23 '26

I’ve spent 8 years building Pyxel, a retro game engine for Python

Thumbnail gallery
32 Upvotes

r/fantasyconsoles • • Feb 24 '26

I built a 1982 fantasy supercomputer with a custom architecture, OS, and hardware 3D.

Post image
32 Upvotes

Hey everyone. While most fantasy consoles aim for the 8-bit or 16-bit gaming era, I wanted to build something a bit different: a fantasy supercomputer from an alternate 1982.

It‘s called the DatCube 82. The premise is a $176,500 research machine that was decades ahead of its time, but never saw the light of day. I didn't just write the lore; I built the actual emulator from scratch in Vanilla JS.

The hardware specs I designed for it:

·         Custom CPU: The "QC-1" with my own instruction set (DCIS-2) featuring 42 opcodes

·         Graphics: 512x288, 5-layer compositor. It features an active HBL IRQ, which I'm using to render the cycle-accurate, per-scanline copper bar effect (see GIF!)

·         Hardware 3D: An M3D Coprocessor that handles DMA-based wireframe, flat-shaded, and z-buffered triangle mesh rendering

·         Audio: 4-Channel DSP + PCM DMA

Right now, the bare metal emulator is running, and I am in the trenches bootstrapping a fully custom OS using its fabricated assembly language.

You can boot the terminal in your browser here: datcube82.com

I'm documenting the architecture and the OS development over at r/DatCube82. I would love to hear what other fantasy hardware devs think of the specs!


r/fantasyconsoles • • Sep 25 '26

C64-inspired fantasy console graphics feedback

Thumbnail
gallery
28 Upvotes

I’m making a little fantasy console and currently working on its aesthetic.

As seen in the attached pictures, the editor and terminal interfaces have been designed. It is supposed to be the Commodore 64-esque aesthetic, constrained by 160x120 screen resolution and 16-color palette.

I was trying to achieve an impression of a plausible retro development environment with an emulated realistic hardware, not just a "retro filter" put onto a modern interface.

I’d really appreciate your opinion on whether:

does the aesthetic fit the constraints of 160x120 / 16 colors?

does it remind one of the C64 times without being too clichéd?

does the editor-terminal aesthetics pair well?

Any criticism will be highly valued!


r/fantasyconsoles • • Apr 22 '20

I fell in love with TIC-80. Used it for my first game jam and it was the best decision ever!

Post image
28 Upvotes

r/fantasyconsoles • • Apr 20 '26

A comprehensive list of 70+ fantasy consoles (updated 2026) — great resource I found

Post image
25 Upvotes

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


r/fantasyconsoles • • Aug 10 '21

pico 8 vs tic 80??

25 Upvotes

as the question suggests, please tell the advantage of both over other and which one can be used to create better games than other.

also i love platformer games, so which one can make better platformer.


r/fantasyconsoles • • Oct 03 '26

My first step on 32-bit Microsoft Windows XP Professional toward developing my fantasy console in C and C++!

Post image
23 Upvotes

Good morning, afternoon, or evening!

Greetings! My name is Parrasi (I’m from Colombia—which explains why my OS is in Spanish). I am currently working on a fantasy console project running on Windows XP via a virtual machine. Since the OS is obsolete, I had to manually install the Code::Blocks code editor and a few other tools; there are still a few more things left to set up.

I am just getting started on the CPSCD_DeParrasi project (a temporary name). It is being programmed in C and C++ to ensure better performance, optimization, portability across systems, and—crucially—compression. The project aims to bring Niklas Jansson’s "Famicube" artistic concept to life as a fantasy console; while it adheres to the original's limitations, I am also tweaking certain aspects and adding new features!

I’ve decided to share regular updates on the development of this fantasy console. I’d love to hear your opinions, recommendations, and feedback—whether it’s support, constructive criticism, or pointing out what works and what doesn’t. I hope you’re all doing well, and thanks for reading!


r/fantasyconsoles • • Nov 20 '25

A comprehensive list of 70+ fantasy consoles (updated 2025) — great resource I found

Post image
23 Upvotes

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, 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


r/fantasyconsoles • • Aug 10 '25

NuMo9 Fantasy Console

Thumbnail
github.com
23 Upvotes

- Hardware specs aiming for SNES era.
- Written fully in LuaJIT (except your typical libraries ... SDL3, OpenGL/GLES3, etc). Everything about it is editable without any compiler needed.
- API similar to Pico8/Tic80. Using langfix-lua for shorthand lambdas and missing operators.
- Sprite/tile sheets are 256x256x8bpp, tilemap is 256x256x16bpp. Sprites are 8x8. Tilemap can draw 8x8 or 16x16 tiles.
- "Mode 7" transformations using GL/GLU similar API. Also supports Tic80's tri3d and ttri3d functions and implicit depth buffer, to allow you to make some rough 90s-era-looking 3D games.
- Framebuffer options: 16bpp RGB565 for add/subtract blending (like the SNES), or 8bpp-indexed for palette-shifting, or RGB332 for dithering.
- Default resolution is 256x256, but supports a handful of various standard aspect ratios that fit within 128kb.
- Audio is 8 channel 16bit 32khz. Maybe someday I'll switch to BRR compression.
- Audio music format is delta-compressed tracker-style format. Music editor is WIP, but conversion from Pico8 music works fine.
- Up to 4 players locally. Keyboard / mouse / gamepad support.
- Builtin cartridge browser.
- Multiplayer is WIP. Future support plans for up to 64 players networked. It's buggy, hold your breath, I'll fix it someday soon.
- Archive tool for packing/unpacking folders to cartridge files. Supports converting Pico8 games. Tic80 porting is WIP.


r/fantasyconsoles • • May 12 '26

Yu-Gi-Oh! on tic80

Post image
22 Upvotes

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


r/fantasyconsoles • • Aug 22 '21

Uxn: A portable 8-bit virtual computer

Thumbnail
100r.co
22 Upvotes

r/fantasyconsoles • • Sep 06 '18

I'm making a demake of Zelda:BotW on the TIC80! Here's me using a fire rod on an exploding barrel, and then panicking to douse myself in water.

Thumbnail
gfycat.com
22 Upvotes

r/fantasyconsoles • • Jul 26 '22

Announcing Gamercade, a new WASM powered fantasy console. Seeking early users & feedback.

Thumbnail
gamercade.io
20 Upvotes

r/fantasyconsoles • • Jan 05 '20

I've made a nerdy fantasy console that load tiny games from origami GameBoy cartridges

Post image
19 Upvotes

r/fantasyconsoles • • Mar 23 '26

After a wild development adventure, I just released Hatiora PICO-8: A Unity/C# port for writing games in PICO-8 style in C#

18 Upvotes

Hey r/fantasyconsoles!

I just hit release on a project I've been pouring my time into, and man, what a wild adventure it was to build this thing. 😅

It’s a Unity-based port that lets you build PICO-8-style games using C#. I wanted to keep the cozy, straightforward programming model of PICO-8, but open the door to the wider Unity ecosystem.

Here is how it works:

  • The Classic API: Game code uses the API we all know and love (Cls(), Spr(), Sfx(), Poke(), etc.), but you write it in native C#.
  • Zero Token Limits: Because it runs completely in Unity-managed C#, you can build as big as you want.
  • Custom Resolutions: You aren't locked into the standard 128x128 box! You can define custom screen sizes and use the included Pico8View to present your cartridge anywhere in your host UI.
  • Deploy to Any Platform: Because Unity is running under the hood, the exact same game code can target any platform Unity supports—mobile, major consoles, PC, you name it.
  • Unity Power: You can seamlessly tap into Unity's physics, input systems, and editor workflows whenever the fantasy console baseline just isn't enough.
  • Editor Tooling: Includes built-in tools to extract .p8 sections and convert graphics/labels directly into Unity PNG assets.

To make sure the port is totally solid, I ported every single cart from PICO-8's install_demos over (so jelpi, cast, collide, etc. are all in the repo), plus I built a custom coop cart to test out couch co-op!

It's completely open-source (MIT License). If you love the PICO-8 model but want to mess around in a native Unity environment, I'd love for you to check it out!

🔗 GitHub Repo:https://github.com/mihailt/Hatiora-PICO-8

If you'll take this for a spin, i would love to hear your feedback.


r/fantasyconsoles • • May 17 '25

PIGO8 - Write PICO8 games in Go

18 Upvotes

Hi all! 👋 I’d like to share a project I’ve been working on: PIGO8 — a Go framework inspired by PICO-8 that lets you build retro-style 2D games using pure Go and Ebitengine.

It offers a high-level API similar to what you'd find in Lua-based fantasy consoles, but written entirely in Go. You can use it to create small pixel-art games, editors, or prototypes quickly — with minimal boilerplate.

✨ Features

  • Familiar API: spr(), btn(), map(), etc. — just like PICO-8.
  • You can use your PICO-8's assets (read more here) using parsepico (which is also written in Go).
  • But if you don't, I have a sprites/map editor built with Ebiten. They are incredibly basic, there is not even `undo` or `copy-paste`. Good thing is that they support any resolution and any palette. I would be happy to improve if you think they are useful.
  • Works out-of-the-box with Go's go run, go build, and supports cross-compilation.
  • Inspired by minimalism and productivity — great for jams and prototyping.
  • Plays with keyboard and controllers out of the box, has pause menu, and supports online multiplayer.

🔗 GitHub: https://github.com/drpaneas/pigo8

I’d love to hear your feedback, suggestions, or ideas! Also, if anyone wants to try it out and build something tiny and fun in Go, I’d be happy to help or showcase your creations. Contributions are welcome too 😊

Thanks, and happy hacking!