UNO v1.0.7 — MEGA65 native mode, 80 columns

Changes since v1.0.6

• A native-mode 80-column MEGA65 build, alongside the existing one. The MEGA65 is now the only machine here built twice, because one binary cannot reach all of it. uno-mega65.prg is unchanged: a cc65 c64-target program loading at $0801, which puts the machine in C64 mode. uno-mega65-native-80col.prg loads at $2001 with a BASIC 65 header, which is what actually selects C65/MEGA65 native mode.

  That distinction is the whole point. 80 columns were never blocked by the video chip -- VIC-IV is perfectly capable -- but by the mode: the C64 never had 80 columns, so setting VIC-IV's H640 bit from inside C64 mode changes nothing. Colour RAM makes it concrete. An 80x25 screen is 2000 cells each wanting its own colour byte, and a C64-mode program can only reach the 1K window at $D800; there is nowhere to put the other 976. In native mode, mega65-libc reaches the real colour RAM at $FF80000 through the 45GS02's 32-bit addressing, and every cell gets its colour.

  Since cc65 has no MEGA65 target at all, the native build uses llvm-mos. Unlike the TMS9900, vbcc and Open Watcom toolchains this repo needed, it ships prebuilt -- and it generates markedly tighter code: 11,316 bytes against cc65's 26,042 for the same game on the same machine.

• What the extra width buys. Cards are 5x4 instead of 3x4, which is enough to draw each one as a solid block of the suit colour with the value knocked out of it by the VIC-IV's reverse attribute -- the look the X16, VBXE, F256 and DOS ports build from per-cell foreground+background, done here with a single attribute bit. A full 20-card hand splits 11/9 across the width rather than 10/10, and the opponents row has room to spell out CPU1 CARDS: 7 instead of abbreviating.

• Native mode simplifies as much as it unlocks. Keyboard input comes from $D610, the MEGA65's ASCII key register: read it for the key waiting, write to pop it. So the native input layer is direct hardware access with no PETSCII translation anywhere -- and no <ascii_charmap.h>, which exists in the cc65 sources purely to stop that compiler applying a charmap to string literals. Joystick is still plain CIA1 at $DC00; the MEGA65 keeps both CIAs. Sound is shared verbatim between the two builds, since the SID is at $D400 either way.

• One thing did not come across: the sprite card toss. The C64-mode build glides a VIC-II hardware sprite from the played card to the discard pile, which works because a probe confirmed the C64 arrangement survives intact -- screen at $0400, VIC bank 0, sprite pointers at $07F8. Native mode relocates screen RAM and changes sprite pointer handling, which is why the MEGA65 has extended pointer registers at $D06C-$D06E in the first place. Rather than guess, the animation is left out of the native build; cards simply appear on the pile. It remains a known follow-up, along with 80x50, palette-based legal-move dimming, and stereo via the second SID.

How to run each one

• uno-c64.prg — Commodore 64. x64sc uno-c64.prg in VICE, or a real C64 + disk/cart tool.
• uno-c128-40col.prg — Commodore 128, 40-column (VIC-IIe). x128 uno-c128-40col.prg.
• uno-c128-80col-vdc.prg — Commodore 128, 80-column (VDC chip). x128 uno-c128-80col-vdc.prg.
• uno-plus4.prg — Commodore Plus/4. xplus4 uno-plus4.prg.
• uno-pet4032.prg — Commodore PET 4032, 40-column (keyboard only, no joystick port). xpet uno-pet4032.prg.
• uno-pet8032.prg — Commodore PET 8032, 80-column (same family as the 4032). xpet -model 8032 uno-pet8032.prg.
• uno-vic20.prg — Commodore VIC-20 + memory expansion. xvic -memory all uno-vic20.prg.
• uno-atari800xl.xex — Atari 800XL. atari800 -xl -xlxe_rom <your ATARIXL.ROM> -nobasic uno-atari800xl.xex (you need your own Atari XL ROM dump; not included here).
• uno-atari800xl-vbxe.xex — Atari 800XL + VBXE. In Altirra: configure the machine as an XL with 64K memory (not a RAMBO-style expansion -- the cc65 runtime's XL check fails under those), a real Atari XL OS ROM, and the VBXE device at the default $D6xx base, then boot the .xex. Now with legal-move highlighting (cards you can't play are dimmed in their own darkened suit color so the playable ones stand out; an all-unplayable hand shows a "press UP to draw" hint) and a bolder pulsing selection cursor. Verified in AltirraSDL/AltirraBridge; see atari/README.md for the exact recipe.
• uno-atari800xl-vbxe-bmp.xex — Atari 800XL + VBXE, bitmap-graphics edition. Same game as uno-atari800xl-vbxe.xex but rendered in the VBXE's 320x192 256-colour framebuffer (pixel-drawn card faces, fanned hand) instead of the text overlay. Same Altirra setup as the text VBXE build above: XL with 64K memory, a real Atari XL OS ROM, and the VBXE device at the default $D6xx base.
• uno-atariste.tos — Atari ST or STE. In Hatari, put it on an emulated GEMDOS drive and autostart it: hatari --machine ste --tos <your tos.img> --harddrive <folder containing uno-atariste.tos> --auto 'C:\UNO-ATARISTE.TOS' (you need your own TOS ROM, or free EmuTOS; not included here). Or just copy it onto a floppy/hard-drive image and double-click it from the GEM desktop. Runs on a plain ST too -- it detects which machine it's on and drops from the STE's 4096-colour palette to the ST's 512 automatically. Keyboard only (see Controls).
• uno-apple2e.system — Apple IIe (enhanced), ProDOS .SYSTEM file. This is not a bootable disk image by itself — see the apple/ README section for how to inject it into a ProDOS disk image, then run it in MAME's apple2ee driver.
• uno-amiga — Commodore Amiga, Kickstart 2.0+. In FS-UAE, put this binary in a folder alongside an s/startup-sequence file whose only line is uno-amiga, then mount that folder as the boot hard drive with a Kickstart 2.0+ ROM — it autostarts on boot, no disk image and no shell typing needed: fs-uae --amiga-model=A1200 --kickstart_file=<your kickstart.rom> --hard_drive_0=<that folder>. (To run it by hand instead, drop the startup-sequence and type uno-amiga at the AmigaDOS shell.)
• uno-amiga-bmp — Commodore Amiga, Kickstart 2.0+, bitmap-graphics edition. Same game as uno-amiga but rendered as pixel-art cards in a 320x256 16-colour screen instead of colored text. Run it the same way in FS-UAE: put it in a folder with an s/startup-sequence whose only line is uno-amiga-bmp, then mount that folder as the boot hard drive with a Kickstart 2.0+ ROM and it autostarts on boot (fs-uae --amiga-model=A1200 --kickstart_file=<your kickstart.rom> --hard_drive_0=<that folder>). Movement is comma/period and U (see Controls).
• uno-cbm510.prg — Commodore CBM-II (510/P500). xcbm5x0 uno-cbm510.prg in VICE.
• uno-f256k.pgz — Foenix F256K. Copy it onto an F256 SD card image (or a real SD card), boot to SuperBASIC, and run /- uno (/- hands off to the pexec chainloader, which loads uno.pgz and its PGZ header names). Renders cards as solid colour tiles via the Vicky video chip, with real SID sound; keyboard only (,/. move, space plays, U draws, 1-9/0/A-J jump to a hand slot). Developed and verified against a f256k MAME driver.
• uno-ti99-4a.rpk — Texas Instruments TI-99/4A, cartridge image. mame ti99_4a -cart uno-ti99-4a.rpk -ioport peb -ioport:peb:slot2 32kmem — the 32K expansion is required, because the cartridge copies the game into that RAM and runs it there. At the TI title screen press any key, then 2 to pick UNO from the console's selection list. Keyboard only (,/. move, space plays, U draws, 1-9/0/A-J jump to a hand slot) — the TI's arrows are FCTN+S/D/E/X and don't come back as plain ASCII. The .rpk is a zip; uno_b0.bin and uno_b1.bin inside it are the two 8K banks, in that order, for real hardware.
• uno-msx2.rom — MSX2 (and MSX2+ / turbo R), 16K cartridge image. In openMSX: openmsx -machine Philips_NMS_8250 -carta uno-msx2.rom. It boots straight into the game — no BASIC, no menu, no keypress to get past a selection screen. This is the one asset here that needs no ROM of your own: openMSX ships the free C-BIOS, so -machine C-BIOS_MSX2 runs it too (and boots faster). Cursor keys or a joystick in port 1 move the cursor, space or return plays/confirms, U or cursor-up draws, 1-9/0/A-J jump to a hand slot. Real hardware works too — it's a plain 16K ROM image for a standard cartridge.
• uno-dos-cga.exe — MS-DOS, CGA. The baseline build: runs on a stock IBM PC or PC/XT and on every PC since. In DOSBox or DOSBox-X, mount a folder containing it and run UNO.EXE; on real hardware or in 86Box (machine = IBM XT, video = CGA), copy it off the floppy image below. Arrow keys or U/space; 1-9/0/A-J jump to a hand slot; ESC quits to DOS.
• uno-dos-ega.exe — MS-DOS, EGA. 640x350 in 16 colours, pixel-art cards. Needs an EGA card or better (-machine ega in DOSBox-X); same 8088 code as the CGA build, so no faster CPU is required. Same controls.
• uno-dos-vga.exe — MS-DOS, VGA. 320x200 in 256 colours, with the suits programmed to the real UNO colours. Needs a VGA card (-machine vgaonly in DOSBox-X). Same controls.
• uno-dos-floppy.img — all three of the above on a 1.44M FAT12 floppy image, which is the easiest way onto an emulated or real PC: attach it as drive A: and run A:\UNO.EXE, A:\UNOEGA.EXE or A:\UNOVGA.EXE depending on your video card.
• uno-zxspectrum.sna — Sinclair ZX Spectrum 48K, ready-to-run snapshot (no LOAD needed). mame spectrum -snapshot uno-zxspectrum.sna, or drag onto any emulator that accepts .sna files. You need your own ZX Spectrum 48K ROM for MAME; not included her...

UNO for Vintage Computers v1.0.6

Changes since v1.0.5

• MS-DOS port added, in three builds. A sixth CPU family for the repo -- Intel x86 -- built with Open Watcom for the 8088 in real mode, which is what buys the reach: one binary runs on a stock 1981 IBM PC or PC/XT, on a Pentium, on DOSBox and on FreeDOS alike. Nothing here needs a 286, not even the graphics builds -- a video card is not a CPU.

  uno-dos-cga.exe is CGA 80x25 colour text. Per-cell foreground and background gives the same solid card tiles as the X16/VBXE/F256/MEGA65 ports, but at twice the C64's width, so the whole hand fits as two straight rows of ten with no overlapping fan. The suits are the real UNO colours only because blinking is turned off: CGA's attribute byte has three bits of background, so backgrounds are normally the eight dark shades and yellow comes out brown -- clearing the blink bit re-purposes it as background intensity and unlocks all sixteen.

  uno-dos-ega.exe is EGA mode 10h: 640x350 in 16 colours, the highest resolution of any port in this repo. uno-dos-vga.exe is VGA mode 13h: 320x200 with a programmable 256-colour palette, so the suits are programmed to the actual UNO colours rather than picked from a fixed sixteen. Both share one ui_bmp.c over two backends that are about as far apart as PC graphics hardware gets -- EGA's four planes all sit at A000:0000 at once and a CPU write triggers the card's ALU (Set/Reset plus a bit mask, with the latches loaded by a dummy read), while mode 13h is one byte per pixel and a store, the simplest video hardware in the whole repo.

  Sound is the PC speaker, one square-wave voice via timer channel 2 of the 8253 -- so arpeggios where the MSX2 and TI-99/4A play chords. Its divider constant 1193182/Hz comes off the same NTSC colourburst crystal as those two machines' sound chips, making it the third in the repo to do so.

• CGA snow, which is a hardware defect rather than a bug. The first working build speckled during CPU turns. The 6845 CRTC and the CPU share the regen buffer at B800:0000 with no arbitration, so a CPU write while the card is fetching display data costs the CRTC its cycle and puts garbage on screen. Every write now waits for bit 0 of 0x3DA -- but only on real CGA, since EGA and later never had the problem and should not pay the poll loop. Worth recording because it is invisible on modern hardware: developing against VGA would have shipped a port that snowed on exactly the machine it is named for.

• A verification trick the other ports cannot use. DOS can write files, so these builds report what they actually drew instead of being screenshotted: the CGA build dumps its text buffer and attribute map as readable text, and the graphics builds dump raw pixels for a host script to turn into PNGs. That caught a layout bug, proved the bright-background trick had taken, and settled by reading a pixel whether a highlight was drawing when it was too thin to see.

How to run each one

• uno-c64.prg — Commodore 64. x64sc uno-c64.prg in VICE, or a real C64 + disk/cart tool.
• uno-c128-40col.prg — Commodore 128, 40-column (VIC-IIe). x128 uno-c128-40col.prg.
• uno-c128-80col-vdc.prg — Commodore 128, 80-column (VDC chip). x128 uno-c128-80col-vdc.prg.
• uno-plus4.prg — Commodore Plus/4. xplus4 uno-plus4.prg.
• uno-pet4032.prg — Commodore PET 4032, 40-column (keyboard only, no joystick port). xpet uno-pet4032.prg.
• uno-pet8032.prg — Commodore PET 8032, 80-column (same family as the 4032). xpet -model 8032 uno-pet8032.prg.
• uno-vic20.prg — Commodore VIC-20 + memory expansion. xvic -memory all uno-vic20.prg.
• uno-atari800xl.xex — Atari 800XL. atari800 -xl -xlxe_rom <your ATARIXL.ROM> -nobasic uno-atari800xl.xex (you need your own Atari XL ROM dump; not included here).
• uno-atari800xl-vbxe.xex — Atari 800XL + VBXE. In Altirra: configure the machine as an XL with 64K memory (not a RAMBO-style expansion -- the cc65 runtime's XL check fails under those), a real Atari XL OS ROM, and the VBXE device at the default $D6xx base, then boot the .xex. Now with legal-move highlighting (cards you can't play are dimmed in their own darkened suit color so the playable ones stand out; an all-unplayable hand shows a "press UP to draw" hint) and a bolder pulsing selection cursor. Verified in AltirraSDL/AltirraBridge; see atari/README.md for the exact recipe.
• uno-atari800xl-vbxe-bmp.xex — Atari 800XL + VBXE, bitmap-graphics edition. Same game as uno-atari800xl-vbxe.xex but rendered in the VBXE's 320x192 256-colour framebuffer (pixel-drawn card faces, fanned hand) instead of the text overlay. Same Altirra setup as the text VBXE build above: XL with 64K memory, a real Atari XL OS ROM, and the VBXE device at the default $D6xx base.
• uno-atariste.tos — Atari ST or STE. In Hatari, put it on an emulated GEMDOS drive and autostart it: hatari --machine ste --tos <your tos.img> --harddrive <folder containing uno-atariste.tos> --auto 'C:\UNO-ATARISTE.TOS' (you need your own TOS ROM, or free EmuTOS; not included here). Or just copy it onto a floppy/hard-drive image and double-click it from the GEM desktop. Runs on a plain ST too -- it detects which machine it's on and drops from the STE's 4096-colour palette to the ST's 512 automatically. Keyboard only (see Controls).
• uno-apple2e.system — Apple IIe (enhanced), ProDOS .SYSTEM file. This is not a bootable disk image by itself — see the apple/ README section for how to inject it into a ProDOS disk image, then run it in MAME's apple2ee driver.
• uno-amiga — Commodore Amiga, Kickstart 2.0+. In FS-UAE, put this binary in a folder alongside an s/startup-sequence file whose only line is uno-amiga, then mount that folder as the boot hard drive with a Kickstart 2.0+ ROM — it autostarts on boot, no disk image and no shell typing needed: fs-uae --amiga-model=A1200 --kickstart_file=<your kickstart.rom> --hard_drive_0=<that folder>. (To run it by hand instead, drop the startup-sequence and type uno-amiga at the AmigaDOS shell.)
• uno-amiga-bmp — Commodore Amiga, Kickstart 2.0+, bitmap-graphics edition. Same game as uno-amiga but rendered as pixel-art cards in a 320x256 16-colour screen instead of colored text. Run it the same way in FS-UAE: put it in a folder with an s/startup-sequence whose only line is uno-amiga-bmp, then mount that folder as the boot hard drive with a Kickstart 2.0+ ROM and it autostarts on boot (fs-uae --amiga-model=A1200 --kickstart_file=<your kickstart.rom> --hard_drive_0=<that folder>). Movement is comma/period and U (see Controls).
• uno-cbm510.prg — Commodore CBM-II (510/P500). xcbm5x0 uno-cbm510.prg in VICE.
• uno-f256k.pgz — Foenix F256K. Copy it onto an F256 SD card image (or a real SD card), boot to SuperBASIC, and run /- uno (/- hands off to the pexec chainloader, which loads uno.pgz and its PGZ header names). Renders cards as solid colour tiles via the Vicky video chip, with real SID sound; keyboard only (,/. move, space plays, U draws, 1-9/0/A-J jump to a hand slot). Developed and verified against a f256k MAME driver.
• uno-ti99-4a.rpk — Texas Instruments TI-99/4A, cartridge image. mame ti99_4a -cart uno-ti99-4a.rpk -ioport peb -ioport:peb:slot2 32kmem — the 32K expansion is required, because the cartridge copies the game into that RAM and runs it there. At the TI title screen press any key, then 2 to pick UNO from the console's selection list. Keyboard only (,/. move, space plays, U draws, 1-9/0/A-J jump to a hand slot) — the TI's arrows are FCTN+S/D/E/X and don't come back as plain ASCII. The .rpk is a zip; uno_b0.bin and uno_b1.bin inside it are the two 8K banks, in that order, for real hardware.
• uno-msx2.rom — MSX2 (and MSX2+ / turbo R), 16K cartridge image. In openMSX: openmsx -machine Philips_NMS_8250 -carta uno-msx2.rom. It boots straight into the game — no BASIC, no menu, no keypress to get past a selection screen. This is the one asset here that needs no ROM of your own: openMSX ships the free C-BIOS, so -machine C-BIOS_MSX2 runs it too (and boots faster). Cursor keys or a joystick in port 1 move the cursor, space or return plays/confirms, U or cursor-up draws, 1-9/0/A-J jump to a hand slot. Real hardware works too — it's a plain 16K ROM image for a standard cartridge.
• uno-dos-cga.exe — MS-DOS, CGA. The baseline build: runs on a stock IBM PC or PC/XT and on every PC since. In DOSBox or DOSBox-X, mount a folder containing it and run UNO.EXE; on real hardware or in 86Box (machine = IBM XT, video = CGA), copy it off the floppy image below. Arrow keys or U/space; 1-9/0/A-J jump to a hand slot; ESC quits to DOS.
• uno-dos-ega.exe — MS-DOS, EGA. 640x350 in 16 colours, pixel-art cards. Needs an EGA card or better (-machine ega in DOSBox-X); same 8088 code as the CGA build, so no faster CPU is required. Same controls.
• uno-dos-vga.exe — MS-DOS, VGA. 320x200 in 256 colours, with the suits programmed to the real UNO colours. Needs a VGA card (-machine vgaonly in DOSBox-X). Same controls.
• uno-dos-floppy.img — all three of the above on a 1.44M FAT12 floppy image, which is the easiest way onto an emulated or real PC: attach it as drive A: and run A:\UNO.EXE, A:\UNOEGA.EXE or A:\UNOVGA.EXE depending on your video card.
• uno-zxspectrum.sna — Sinclair ZX Spectrum 48K, ready-to-run snapshot (no LOAD needed). mame spectrum -snapshot uno-zxspectrum.sna, or drag onto any emulator that accepts .sna files. You need your own ZX Spectrum 48K ROM for MAME; not included here.
• **un...

UNO for Vintage Computers v1.0.5

Changes since v1.0.4

• MSX2 port added. Z80 like the ZX Spectrum port, but via SDCC rather than z88dk and with far better video to aim at. MSX2 rather than MSX1 for a concrete reason: the MSX1's VDP is the same TMS9918A as the TI-99/4A port, with the same "colour belongs to a group of eight character codes" constraint. The V9938 drops it and adds the two things this game wants -- a programmable palette (SCREEN 5 is 256x212, 16 colours out of 512, so the suits are the actual UNO red/yellow/green/blue rather than the nearest of fifteen fixed entries) and a hardware blitter, which is what makes full pixel-art cards affordable on a 3.58MHz Z80 where the Amiga and Atari ST ports need a 68000 for the same look. Glyphs come from the machine's own ROM font via the CGTBL pointer at 0x0004, so the cartridge carries no font of its own. AY-3-8910 PSG sound gives three real voices, so chords rather than beeps -- its tone constant 111861/Hz is identical to the TI-99/4A's SN76489, both being divided down from the same 3.579545MHz colourburst crystal. Ships as a flat 16K cartridge ROM (11,296 bytes used, so no bank switching, unlike the TI-99/4A) and runs unchanged on MSX2+ and turbo R.

  Bringing it up hit four traps worth recording, all written up in msx2/. Three are the V9938's: the command engine takes pixel coordinates for every command (the manual's "byte units" is about internal granularity, and only means a fill cannot start or stop on an odd pixel); NX == 0 means "the whole width" rather than "nothing", so a naive one-pixel-wide line paints a band across the screen; and the blitter shares the VRAM port with the CPU, so a fill that has been started but not finished will overwrite whatever the CPU writes behind it -- the symptom being that the first line of text after a screen clear vanishes and every later line is fine.

  The fourth is a genuine Z80 hardware erratum. SDCC's __critical compiles to an ld a,i interrupt-state save, and if a maskable interrupt is accepted during that one instruction the Z80 resets the P/V flag regardless of the real IFF2 state. The restore then concludes interrupts were already off, skips the matching ei, and they stay off permanently -- the frame counter stops and the game freezes mid-turn. With thousands of these per screen redraw against a VBLANK every 20ms, the first build survived about seventeen seconds. Plain di/ei instead. openMSX emulates the erratum faithfully, which is the only reason it was findable without real hardware.

• MIT license added. The repo was public but carried no license, which meant default copyright -- no right to use, modify or redistribute any of it. It is now MIT (LICENSE), excluding the two vendored third-party directories that carry their own (c64os/inc/ and c64os/tools/). No machine ROMs are bundled anywhere.

• Project renamed to "UNO for Vintage Computers." The old name described the first few ports, not a lineup that now spans five CPU families and eleven manufacturers. The GitHub repository slug stays commodore-uno so existing clones and links keep working.

• Documentation audit across every port. The Notes section of the main README covered 7 of the 18 ports and now covers all of them, one entry each, ordered to match the table. Also fixed: the Foenix F256K had a table row and a shipping binary but no build instructions anywhere; the CoCo 3 row called the 6809 "a fifth CPU family" and the TI-99/4A row called the TMS9900 "a third", neither of which was right and which contradicted each other; and the TI-99/4A's colour ranges are 24 character codes holding a 23-glyph alphabet, not "24-glyph" ranges -- 24 because colour is assigned a whole 8-code group at a time.

How to run each one

• uno-c64.prg — Commodore 64. x64sc uno-c64.prg in VICE, or a real C64 + disk/cart tool.
• uno-c128-40col.prg — Commodore 128, 40-column (VIC-IIe). x128 uno-c128-40col.prg.
• uno-c128-80col-vdc.prg — Commodore 128, 80-column (VDC chip). x128 uno-c128-80col-vdc.prg.
• uno-plus4.prg — Commodore Plus/4. xplus4 uno-plus4.prg.
• uno-pet4032.prg — Commodore PET 4032, 40-column (keyboard only, no joystick port). xpet uno-pet4032.prg.
• uno-pet8032.prg — Commodore PET 8032, 80-column (same family as the 4032). xpet -model 8032 uno-pet8032.prg.
• uno-vic20.prg — Commodore VIC-20 + memory expansion. xvic -memory all uno-vic20.prg.
• uno-atari800xl.xex — Atari 800XL. atari800 -xl -xlxe_rom <your ATARIXL.ROM> -nobasic uno-atari800xl.xex (you need your own Atari XL ROM dump; not included here).
• uno-atari800xl-vbxe.xex — Atari 800XL + VBXE. In Altirra: configure the machine as an XL with 64K memory (not a RAMBO-style expansion -- the cc65 runtime's XL check fails under those), a real Atari XL OS ROM, and the VBXE device at the default $D6xx base, then boot the .xex. Now with legal-move highlighting (cards you can't play are dimmed in their own darkened suit color so the playable ones stand out; an all-unplayable hand shows a "press UP to draw" hint) and a bolder pulsing selection cursor. Verified in AltirraSDL/AltirraBridge; see atari/README.md for the exact recipe.
• uno-atari800xl-vbxe-bmp.xex — Atari 800XL + VBXE, bitmap-graphics edition. Same game as uno-atari800xl-vbxe.xex but rendered in the VBXE's 320x192 256-colour framebuffer (pixel-drawn card faces, fanned hand) instead of the text overlay. Same Altirra setup as the text VBXE build above: XL with 64K memory, a real Atari XL OS ROM, and the VBXE device at the default $D6xx base.
• uno-atariste.tos — Atari ST or STE. In Hatari, put it on an emulated GEMDOS drive and autostart it: hatari --machine ste --tos <your tos.img> --harddrive <folder containing uno-atariste.tos> --auto 'C:\UNO-ATARISTE.TOS' (you need your own TOS ROM, or free EmuTOS; not included here). Or just copy it onto a floppy/hard-drive image and double-click it from the GEM desktop. Runs on a plain ST too -- it detects which machine it's on and drops from the STE's 4096-colour palette to the ST's 512 automatically. Keyboard only (see Controls).
• uno-apple2e.system — Apple IIe (enhanced), ProDOS .SYSTEM file. This is not a bootable disk image by itself — see the apple/ README section for how to inject it into a ProDOS disk image, then run it in MAME's apple2ee driver.
• uno-amiga — Commodore Amiga, Kickstart 2.0+. In FS-UAE, put this binary in a folder alongside an s/startup-sequence file whose only line is uno-amiga, then mount that folder as the boot hard drive with a Kickstart 2.0+ ROM — it autostarts on boot, no disk image and no shell typing needed: fs-uae --amiga-model=A1200 --kickstart_file=<your kickstart.rom> --hard_drive_0=<that folder>. (To run it by hand instead, drop the startup-sequence and type uno-amiga at the AmigaDOS shell.)
• uno-amiga-bmp — Commodore Amiga, Kickstart 2.0+, bitmap-graphics edition. Same game as uno-amiga but rendered as pixel-art cards in a 320x256 16-colour screen instead of colored text. Run it the same way in FS-UAE: put it in a folder with an s/startup-sequence whose only line is uno-amiga-bmp, then mount that folder as the boot hard drive with a Kickstart 2.0+ ROM and it autostarts on boot (fs-uae --amiga-model=A1200 --kickstart_file=<your kickstart.rom> --hard_drive_0=<that folder>). Movement is comma/period and U (see Controls).
• uno-cbm510.prg — Commodore CBM-II (510/P500). xcbm5x0 uno-cbm510.prg in VICE.
• uno-f256k.pgz — Foenix F256K. Copy it onto an F256 SD card image (or a real SD card), boot to SuperBASIC, and run /- uno (/- hands off to the pexec chainloader, which loads uno.pgz and its PGZ header names). Renders cards as solid colour tiles via the Vicky video chip, with real SID sound; keyboard only (,/. move, space plays, U draws, 1-9/0/A-J jump to a hand slot). Developed and verified against a f256k MAME driver.
• uno-ti99-4a.rpk — Texas Instruments TI-99/4A, cartridge image. mame ti99_4a -cart uno-ti99-4a.rpk -ioport peb -ioport:peb:slot2 32kmem — the 32K expansion is required, because the cartridge copies the game into that RAM and runs it there. At the TI title screen press any key, then 2 to pick UNO from the console's selection list. Keyboard only (,/. move, space plays, U draws, 1-9/0/A-J jump to a hand slot) — the TI's arrows are FCTN+S/D/E/X and don't come back as plain ASCII. The .rpk is a zip; uno_b0.bin and uno_b1.bin inside it are the two 8K banks, in that order, for real hardware.
• uno-msx2.rom — MSX2 (and MSX2+ / turbo R), 16K cartridge image. In openMSX: openmsx -machine Philips_NMS_8250 -carta uno-msx2.rom. It boots straight into the game — no BASIC, no menu, no keypress to get past a selection screen. This is the one asset here that needs no ROM of your own: openMSX ships the free C-BIOS, so -machine C-BIOS_MSX2 runs it too (and boots faster). Cursor keys or a joystick in port 1 move the cursor, space or return plays/confirms, U or cursor-up draws, 1-9/0/A-J jump to a hand slot. Real hardware works too — it's a plain 16K ROM image for a standard cartridge.
• uno-zxspectrum.sna — Sinclair ZX Spectrum 48K, ready-to-run snapshot (no LOAD needed). mame spectrum -snapshot uno-zxspectrum.sna, or drag onto any emulator that accepts .sna files. You need your own ZX Spectrum 48K ROM for MAME; not included here.
• uno-c64os.zip — C64 OS application bundle (about.t/main.o/menu.m inside a uno_1.0/ folder). This one's different from every other asset here: it's not a standalone binary you hand to an emula...

UNO for Vintage Computers v1.0.4

Changes since v1.0.3

• Texas Instruments TI-99/4A port added. A fifth CPU family for the repo -- TI's 16-bit TMS9900 -- built with gcc 4.4 carrying mburkley's TMS9900 patches plus Tursi's libti99, since nothing packages a TMS9900 compiler. Its TMS9918A has no per-cell colour at all: one 32-byte colour table colours groups of eight character codes, so colour belongs to the glyph, not the screen position. The port buys colour back the classic TI way, by spending character codes on it -- six 24-code ranges (four suits, wild, and a cursor highlight) each hold the same 23-glyph card alphabet in their own colour, budgeted across exactly 32 groups -- giving solid colour card tiles like the X16/VBXE/F256 tile ports on hardware that nominally can't do them. SN76489 sound means three real voices, so UNO and the win flourish are chords rather than beeps. At ~12K the game outgrows the 8K cartridge window, so it ships as a two-bank cart whose ROM stub copies the program into the 32K expansion and runs it from RAM.

• Foenix F256K port added. The first 65C02 Foenix machine here, and the first target where sound comes for free from the C64 port: the F256's left SID sits at $D400, register-for-register identical to a 6581/8580 -- same base address the C64 uses -- so f256snd.c is a close port of the C64 port's sid.c. Cards render as solid colour tiles in the Vicky per-cell-colour text mode (like the X16/VBXE tile ports); the char and colour matrices share the $C000 I/O window, paged via MMU_IO_CTRL ($0001), while SID and the Vicky control registers live in the fixed I/O page 0 alongside it. Built with cc65, packaged as a PGZ loaded off the SD card by FoenixMCP and run from SuperBASIC with /- uno; keyboard input polls the kernel's event queue. Verified end-to-end (including audible SID effects) in a f256k MAME driver. Source in f256/.

• Amiga: bitmap-graphics build added. A second Amiga build (make bmp) that renders the game as pixel-art cards in a custom 320x256, 16-colour lores screen instead of the text build's console.device characters -- the same card/hand design as the Atari ST and X16/VBXE bitmap builds. It draws through graphics.library, so unlike the ST port (which hand-masks four bitplanes) the planar framebuffer is the OS's job and the card bodies are RectFill()s that run on the blitter; text is the topaz ROM font via Text(), so no embedded font is needed. The text build (uno-amiga) is unchanged. Source in amiga/ (gfx.c/ui_bmp.c/main_bmp.c).

• Atari ST/STE port added. The second 68000 machine here, and a completely different target from the Amiga -- GEMDOS/TOS rather than AmigaOS, so it needs its own toolchain (vbcc with the m68k-atari target, built from source; there's no Homebrew package and the old cross-mint tap is gone). It's also the only machine in the collection with no text mode at all, and its framebuffer isn't chunky -- it's four bitplanes interleaved by word, so a pixel's colour is assembled from the same bit position across four separate 16-bit words. The video layer masks whole 16-pixel word groups across all four planes and draws card faces as nested fills to stay at word speed. Full-colour pixel-art cards and a fanned hand in 320x200/16 colours. The palette is written in STE 4-bit-per-gun encoding, whose extra bit sits in bit 3 as the least significant bit and is simply ignored by a plain ST -- 4096 colours on an STE, a graceful fallback to the ST's 512, from one code path -- and the title screen tells you which machine it detected. Carries its own 8x8 font (the ROM font is only reachable via Line-A/VDI), YM2149 sound through XBIOS Dosound(). Source in ste/.

  Bringing it up also surfaced a latent bug the 6502 ports had been hiding for the whole life of the project: the shared GameState put a single draw_count byte between the two Card arrays, landing discard_pile on odd offset 217. Card is two bytes with byte alignment, so that's legal -- but the compiler renders a two-byte Card assignment as one move.w, and a 68000 traps on a word access to an odd address. Harmless everywhere else, an instant Address Error here.

• Atari 800XL VBXE: bitmap-graphics build added. A third Atari build (make all-vbxe-bmp) that renders the game in the VBXE Overlay's SR mode -- a real 320x192, 8bpp chunky framebuffer with a 256-entry 24-bit palette -- instead of the text overlay. Pixel-art card faces (drop shadow, suit border, corner values, centre badge) and a fanned overlapping hand, with the Atari ROM charset blitted into the framebuffer for text. Selecting the mode meant deriving the SR-mode XDL from Altirra's own kOvModeTable (the graphics entry needs the GMON control bit rather than text's TMON). Same rules, input and POKEY sound as the text build; the text uno-atari800xl-vbxe.xex is unchanged.

• Amiga text build: centred layout + much faster redraws. The title and table were centred on console.device's full 80-column model, but only ~65 columns are actually visible, so they sat right of centre -- now centred on the visible width, lined up with the opponents row and hand. And redraws were doing one synchronous DoIO per escape/character (hundreds to over a thousand per turn); output is now batched into a single write per frame, so the screen no longer visibly repaints a character at a time.

How to run each one

• uno-c64.prg — Commodore 64. x64sc uno-c64.prg in VICE, or a real C64 + disk/cart tool.
• uno-c128-40col.prg — Commodore 128, 40-column (VIC-IIe). x128 uno-c128-40col.prg.
• uno-c128-80col-vdc.prg — Commodore 128, 80-column (VDC chip). x128 uno-c128-80col-vdc.prg.
• uno-plus4.prg — Commodore Plus/4. xplus4 uno-plus4.prg.
• uno-pet4032.prg — Commodore PET 4032, 40-column (keyboard only, no joystick port). xpet uno-pet4032.prg.
• uno-pet8032.prg — Commodore PET 8032, 80-column (same family as the 4032). xpet -model 8032 uno-pet8032.prg.
• uno-vic20.prg — Commodore VIC-20 + memory expansion. xvic -memory all uno-vic20.prg.
• uno-atari800xl.xex — Atari 800XL. atari800 -xl -xlxe_rom <your ATARIXL.ROM> -nobasic uno-atari800xl.xex (you need your own Atari XL ROM dump; not included here).
• uno-atari800xl-vbxe.xex — Atari 800XL + VBXE. In Altirra: configure the machine as an XL with 64K memory (not a RAMBO-style expansion -- the cc65 runtime's XL check fails under those), a real Atari XL OS ROM, and the VBXE device at the default $D6xx base, then boot the .xex. Now with legal-move highlighting (cards you can't play are dimmed in their own darkened suit color so the playable ones stand out; an all-unplayable hand shows a "press UP to draw" hint) and a bolder pulsing selection cursor. Verified in AltirraSDL/AltirraBridge; see atari/README.md for the exact recipe.
• uno-atari800xl-vbxe-bmp.xex — Atari 800XL + VBXE, bitmap-graphics edition. Same game as uno-atari800xl-vbxe.xex but rendered in the VBXE's 320x192 256-colour framebuffer (pixel-drawn card faces, fanned hand) instead of the text overlay. Same Altirra setup as the text VBXE build above: XL with 64K memory, a real Atari XL OS ROM, and the VBXE device at the default $D6xx base.
• uno-atariste.tos — Atari ST or STE. In Hatari, put it on an emulated GEMDOS drive and autostart it: hatari --machine ste --tos <your tos.img> --harddrive <folder containing uno-atariste.tos> --auto 'C:\UNO-ATARISTE.TOS' (you need your own TOS ROM, or free EmuTOS; not included here). Or just copy it onto a floppy/hard-drive image and double-click it from the GEM desktop. Runs on a plain ST too -- it detects which machine it's on and drops from the STE's 4096-colour palette to the ST's 512 automatically. Keyboard only (see Controls).
• uno-apple2e.system — Apple IIe (enhanced), ProDOS .SYSTEM file. This is not a bootable disk image by itself — see the apple/ README section for how to inject it into a ProDOS disk image, then run it in MAME's apple2ee driver.
• uno-amiga — Commodore Amiga, Kickstart 2.0+. In FS-UAE, put this binary in a folder alongside an s/startup-sequence file whose only line is uno-amiga, then mount that folder as the boot hard drive with a Kickstart 2.0+ ROM — it autostarts on boot, no disk image and no shell typing needed: fs-uae --amiga-model=A1200 --kickstart_file=<your kickstart.rom> --hard_drive_0=<that folder>. (To run it by hand instead, drop the startup-sequence and type uno-amiga at the AmigaDOS shell.)
• uno-amiga-bmp — Commodore Amiga, Kickstart 2.0+, bitmap-graphics edition. Same game as uno-amiga but rendered as pixel-art cards in a 320x256 16-colour screen instead of colored text. Run it the same way in FS-UAE: put it in a folder with an s/startup-sequence whose only line is uno-amiga-bmp, then mount that folder as the boot hard drive with a Kickstart 2.0+ ROM and it autostarts on boot (fs-uae --amiga-model=A1200 --kickstart_file=<your kickstart.rom> --hard_drive_0=<that folder>). Movement is comma/period and U (see Controls).
• uno-cbm510.prg — Commodore CBM-II (510/P500). xcbm5x0 uno-cbm510.prg in VICE.
• uno-f256k.pgz — Foenix F256K. Copy it onto an F256 SD card image (or a real SD card), boot to SuperBASIC, and run /- uno (/- hands off to the pexec chainloader, which loads uno.pgz and its PGZ header names). Renders cards as solid colour tiles via the Vicky video chip, with real SID sound; keyboard only (,/. move, space plays, U draws, 1-9/0/A-J jump to a hand slot). Developed and verified against a f256k MAME driver.
• uno-ti99-4a.rpk — Texas Instruments TI-99/4A, cartri...

UNO for Vintage Computers v1.0.3

Changes since v1.0.2

• Amiga: bitmap-graphics build added. A second Amiga build (make bmp) that renders the game as pixel-art cards in a custom 320x256, 16-colour lores screen instead of the text build's console.device characters -- the same card/hand design as the Atari ST and X16/VBXE bitmap builds. It draws through graphics.library, so unlike the ST port (which hand-masks four bitplanes) the planar framebuffer is the OS's job and the card bodies are RectFill()s that run on the blitter; text is the topaz ROM font via Text(), so no embedded font is needed. The text build (uno-amiga) is unchanged. Source in amiga/ (gfx.c/ui_bmp.c/main_bmp.c).

• Atari ST/STE port added. The second 68000 machine here, and a completely different target from the Amiga -- GEMDOS/TOS rather than AmigaOS, so it needs its own toolchain (vbcc with the m68k-atari target, built from source; there's no Homebrew package and the old cross-mint tap is gone). It's also the only machine in the collection with no text mode at all, and its framebuffer isn't chunky -- it's four bitplanes interleaved by word, so a pixel's colour is assembled from the same bit position across four separate 16-bit words. The video layer masks whole 16-pixel word groups across all four planes and draws card faces as nested fills to stay at word speed. Full-colour pixel-art cards and a fanned hand in 320x200/16 colours. The palette is written in STE 4-bit-per-gun encoding, whose extra bit sits in bit 3 as the least significant bit and is simply ignored by a plain ST -- 4096 colours on an STE, a graceful fallback to the ST's 512, from one code path -- and the title screen tells you which machine it detected. Carries its own 8x8 font (the ROM font is only reachable via Line-A/VDI), YM2149 sound through XBIOS Dosound(). Source in ste/.

  Bringing it up also surfaced a latent bug the 6502 ports had been hiding for the whole life of the project: the shared GameState put a single draw_count byte between the two Card arrays, landing discard_pile on odd offset 217. Card is two bytes with byte alignment, so that's legal -- but the compiler renders a two-byte Card assignment as one move.w, and a 68000 traps on a word access to an odd address. Harmless everywhere else, an instant Address Error here.

• Atari 800XL VBXE: bitmap-graphics build added. A third Atari build (make all-vbxe-bmp) that renders the game in the VBXE Overlay's SR mode -- a real 320x192, 8bpp chunky framebuffer with a 256-entry 24-bit palette -- instead of the text overlay. Pixel-art card faces (drop shadow, suit border, corner values, centre badge) and a fanned overlapping hand, with the Atari ROM charset blitted into the framebuffer for text. Selecting the mode meant deriving the SR-mode XDL from Altirra's own kOvModeTable (the graphics entry needs the GMON control bit rather than text's TMON). Same rules, input and POKEY sound as the text build; the text uno-atari800xl-vbxe.xex is unchanged.

• Commander X16: bitmap-graphics build added. A second, separate X16 build (make bmp) that renders the whole game in a 320x240 256-colour bitmap framebuffer instead of text/tiles -- pixel-drawn card faces (drop shadow, suit border, centre pip) and a fanned overlapping hand -- built on the KERNAL's GRAPH_* framebuffer API. Same rules/input/sound as the text build; the text uno-cx16.prg is unchanged. Source in x16/ (ui_bmp.c/vbmp.c/graph.s).

• Commander X16 port added. The modern 8-bit machine, via cc65's cx16 target. Talks straight to its VERA video chip -- per-cell foreground+background color for solid colored card tiles with legal-move dimming (unplayable cards darkened so the playable ones stand out) and a bolder pulsing selection highlight, a real hardware-sprite card toss (VERA has 128 sprites, so genuine sprite motion rather than the VBXE port's redraw), and VERA PSG sound -- the same feature set as the C64/VBXE ports. Source in x16/.

• MEGA65 port added. The modern Commodore-65 recreation. Compiles as a cc65 c64-target binary that runs in C64 mode and brings up the VIC-IV video chip through mega65-libc for a per-cell-color 40-column screen (color-bordered card boxes), a VIC-II hardware-sprite card toss on every play, and SID sound directly mapped at $D400. (80-column would need native C65 mode, which a C64-mode binary can't reach; legal-move dimming and stereo dual-SID are noted follow-ups.) Source in mega65/.

• PET 8032 build added. Same 4032 hardware family (monochrome, keyboard only), just 80x25 instead of 40x25 -- separate build target, source is pet/src/main8032.c/petvid8032.c/ui8032.c. Not attached to v1.0.2 even though it landed before that release.

• CBM-II (510/P500) port added. The one CBM-II model with a real VIC-II and SID (same chips as the C64), reached through cc65's pokebsys()/peekbsys() since they live in a separate bank-switched "system bank" plain pointers can't reach. Full-color card borders and SID sound effects.

• ZX Spectrum port added. A genuinely different toolchain from every other port here: Z80 (not 6502) via z88dk instead of cc65. 32x24 text over a bitmap with per-8x8-cell ink/paper color (the classic Spectrum "attribute clash"), cards shown as bracketed color-letter labels like the VIC-20/PET/Atari ports, O/P/Q "keys as joystick" scheme since a real Spectrum has no cursor keys, 1-bit beeper sound.

• C64 OS port added. A real windowed application for Greg Naçu's C64 OS (not a shortcut to the bare-metal C64 port above) -- its own menu, real keyboard-event handling, and the full game engine hand-ported to 6502 assembly against C64 OS's TMP-syntax SDK, since C64 OS predates and isn't compatible with the cc65/C toolchain every other port here uses. Source and design notes in c64os/.

• C64 OS port: rendering performance fix. Every redraw used to re-run the full sequence of ctxdraw_ calls straight against live screen memory, even for things like closing a menu where nothing in the game had actually changed -- visibly slow. Now the app renders into a private off-screen layer buffer gated by a dirty flag, and only blits that buffer to the real screen (a fast raw memory copy) when nothing needs to be redrawn. Same uno-c64os.zip asset below, just rebuilt.

• Tandy CoCo 3 port added. Another genuinely different toolchain: 6809 via CMOC instead of cc65. Cards are still shown as bracketed [label:COLORLETTER+VALUE] like the PET/VIC-20/Atari/ZX Spectrum ports (CoCo3's text mode has no redefinable character generator, so it can't do the C64 port's custom card-shaped tiles), but each card renders in its actual suit color -- the GIME's text-attribute foreground and background turned out to be two independent banks of programmable palette registers, so every color is explicitly set rather than left at boot defaults. Source and hardware notes in coco/.

• ZX Spectrum port: real per-suit card colors. Same upgrade as the CoCo 3 port above -- cards now render in their actual color instead of a single ink, since the Spectrum's famous "attribute clash" turns out to only bite at sub-cell bitmap graphics, not plain text (one character already is one attribute cell). Along the way, found and fixed a real bug: the console driver defaulted every printed character's background to white regardless of what the screen was cleared to, so white text was rendering as an invisible white-on-white block. Same uno-zxspectrum.sna asset below, just rebuilt.

• C128 port: 40-column build brought to C64 parity, 80-column VDC colors fixed. The 40-column (VIC-IIe) build was missing everything the C64 port's later animation/sound work added -- sprite-based card-toss animation, deal-in animation, blinking hand cursor, win-screen border flourish, and most of the distinct SID sound effects -- all ported over now. The 80-column (VDC) build had a real, longstanding color bug: its color constants were copy-pasted from the VIC-II's palette without checking whether the VDC (8563/8568) shares it -- it doesn't, it's a separate RGBI-based color chip with its own 16-entry table, so cards only ever showed in shades of blue and green, never red or yellow. Fixed with the VDC's real documented palette. The VDC build also now runs in C128's 2MHz fast mode (verified first that this doesn't break the frame-pacing timer it depends on, even though the VIC-II's own unwatched picture goes incoherent at that speed, same well-known tradeoff every 2MHz C128 program makes).

• Atari 800XL VBXE port added, then upgraded to C64-port parity. A second Atari build for machines fitted with a VBXE (Video Board XE) FPGA video card: 80-column overlay text mode with real per-character color. The bringup turned into a register-level archaeology project -- the widely-circulated 2009 VBXE v1.0-beta manual documents a palette protocol and a MEMAC banking register that simply don't exist on the FX core all real software (and Altirra's emulation) targets, so writes to them were silently dropped. Root-caused by reading Altirra's own vbxe.cpp and four working VBXE codebases; the full bug-by-bug field guide is in atari/README.md. Once working, brought up to the same feature level as the C64/C128 ports: cards render as solid colored tiles (not bracketed color-letters) with the value centered in a contrasting color, playing a card animates a small colored block from hand to discard pile (the redraw-based equivalent of the C64 port's hardware-sprite toss, since VBXE has no hardware sprites), hands deal in card-by-card at the start of each round, the selection cursor blinks, and winning triggers a rainbow flourish across the win scre...

UNO for Vintage Computers v1.0.2

Changes since v1.0.1

• Amiga port added. A completely different CPU architecture from every other port here (68000, not 6502) -- built with bebbo's amiga-gcc instead of cc65. A custom Intuition screen gives a real 8-color palette (the default Workbench screen only renders a few washed-out shades), text goes through console.device with ANSI escape codes, and 4-channel Paula PCM sound drives a generated sine-wave tone with a volume envelope and multi-note win/uno/challenge fanfares. uno-amiga needs Kickstart 2.0+ and no disk image -- see the main README for how to run it in FS-UAE.

How to run each one

• uno-c64.prg — Commodore 64. x64sc uno-c64.prg in VICE, or a real C64 + disk/cart tool.
• uno-c128-40col.prg — Commodore 128, 40-column (VIC-IIe). x128 uno-c128-40col.prg.
• uno-c128-80col-vdc.prg — Commodore 128, 80-column (VDC chip). x128 uno-c128-80col-vdc.prg.
• uno-plus4.prg — Commodore Plus/4. xplus4 uno-plus4.prg.
• uno-pet4032.prg — Commodore PET 4032 (keyboard only, no joystick port). xpet uno-pet4032.prg.
• uno-vic20.prg — Commodore VIC-20 + memory expansion. xvic -memory all uno-vic20.prg.
• uno-atari800xl.xex — Atari 800XL. atari800 -xl -xlxe_rom <your ATARIXL.ROM> -nobasic uno-atari800xl.xex (you need your own Atari XL ROM dump; not included here).
• uno-apple2e.system — Apple IIe (enhanced), ProDOS .SYSTEM file. This is not a bootable disk image by itself — see the apple/ README section for how to inject it into a ProDOS disk image with apple/tools/make_disk.py, then run it in MAME's apple2ee driver.
• uno-amiga — Commodore Amiga, Kickstart 2.0+. In FS-UAE, mount a folder containing this binary as a hard drive (no disk image needed) and boot with a Kickstart 2.0+ ROM: fs-uae --amiga-model=A1200 --kickstart_file=<your kickstart.rom> --hard_drive_0=<folder containing uno-amiga>, then run it from the AmigaDOS shell.

Controls

Joystick (where the hardware has a port) or keyboard: cursor left/right to pick a card, space/return to play or confirm, cursor up to draw, or jump straight to a card with 1-9, 0, A-J. The Amiga port is the exception — comma/period for left/right and U to draw, since its cursor keys didn't work reliably through the console input path.

Full source, per-platform build instructions, and design notes are in the main README.

UNO for Vintage Computers v1.0.1

Changes since v1.0.0

• VIC-20 fixed. The rendering bug is resolved -- the VIC's video matrix is redirected back to $1E00 (the address that renders correctly) instead of the $1000 the KERNAL relocates it to when it detects expansion RAM, which is where a genuine VIC-chip rendering bug lives. Cards are now also color-coded by suit (the earlier belief that VIC-20 color RAM "didn't visibly affect rendering" turned out to be a side effect of an unrelated white-on-white background bug, fixed alongside this). uno-vic20-KNOWN-BROKEN.prg from v1.0.0 is replaced by a working uno-vic20.prg.
• C128 80-column VDC build added. Alongside the existing 40-column VIC-IIe version, uno-c128-80col-vdc.prg drives the 8563/8568 VDC chip for a full 80-column display with a wider, more spread-out layout.

How to run each one

• uno-c64.prg — Commodore 64. x64sc uno-c64.prg in VICE, or a real C64 + disk/cart tool.
• uno-c128-40col.prg — Commodore 128, 40-column (VIC-IIe). x128 uno-c128-40col.prg.
• uno-c128-80col-vdc.prg — Commodore 128, 80-column (VDC chip). x128 uno-c128-80col-vdc.prg.
• uno-plus4.prg — Commodore Plus/4. xplus4 uno-plus4.prg.
• uno-pet4032.prg — Commodore PET 4032 (keyboard only, no joystick port). xpet uno-pet4032.prg.
• uno-vic20.prg — Commodore VIC-20 + memory expansion. xvic -memory all uno-vic20.prg.
• uno-atari800xl.xex — Atari 800XL. atari800 -xl -xlxe_rom <your ATARIXL.ROM> -nobasic uno-atari800xl.xex (you need your own Atari XL ROM dump; not included here).
• uno-apple2e.system — Apple IIe (enhanced), ProDOS .SYSTEM file. This is not a bootable disk image by itself — see the apple/ README section for how to inject it into a ProDOS disk image with apple/tools/make_disk.py, then run it in MAME's apple2ee driver.

Controls

Joystick (where the hardware has a port) or keyboard: cursor left/right to pick a card, space/return to play or confirm, cursor up to draw, or jump straight to a card with 1-9, 0, A-J.

Full source, per-platform build instructions, and design notes are in the main README.

UNO for Vintage Computers v1.0.0

Prebuilt binaries for every platform in this repo. All built from this tag's source with cc65.

How to run each one

• uno-c64.prg — Commodore 64. x64sc uno-c64.prg in VICE, or a real C64 + disk/cart tool.
• uno-c128-40col.prg — Commodore 128, 40-column (VIC-IIe). x128 uno-c128-40col.prg.
• uno-c128-80col-vdc.prg — Commodore 128, 80-column (VDC chip). x128 uno-c128-80col-vdc.prg.
• uno-plus4.prg — Commodore Plus/4. xplus4 uno-plus4.prg.
• uno-pet4032.prg — Commodore PET 4032 (keyboard only, no joystick port). xpet uno-pet4032.prg.
• uno-vic20-KNOWN-BROKEN.prg — Commodore VIC-20 + memory expansion. Included for completeness only — has an unresolved VIC-chip rendering bug where large parts of a correct, in-memory screen never actually display. See the vic20/ directory for details. Needs xvic -memory all.
• uno-atari800xl.xex — Atari 800XL. atari800 -xl -xlxe_rom <your ATARIXL.ROM> -nobasic uno-atari800xl.xex (you need your own Atari XL ROM dump; not included here).
• uno-apple2e.system — Apple IIe (enhanced), ProDOS .SYSTEM file. This is not a bootable disk image by itself — see the apple/ README section for how to inject it into a ProDOS disk image with apple/tools/make_disk.py, then run it in MAME's apple2ee driver.

Controls

Joystick (where the hardware has a port) or keyboard: cursor left/right to pick a card, space/return to play or confirm, cursor up to draw, or jump straight to a card with 1-9, 0, A-J.

Full source, per-platform build instructions, and design notes are in the main README.