Skip to content

Native games and Ports: launcher, rsos-gamepad, six N64 ports, one Ports list, N64/GameCube pads, HDMI for ports, game store - #14

Open
KurdtNervanna wants to merge 10 commits into
PaddleStroke:mainfrom
KurdtNervanna:native-games-upstream
Open

KurdtNervanna wants to merge 10 commits into
PaddleStroke:mainfrom
KurdtNervanna:native-games-upstream

Conversation

@KurdtNervanna

@KurdtNervanna KurdtNervanna commented Oct 28, 2026 •

Copy link
Copy Markdown
Contributor

This is the single "native games" PR you asked for. It replaces #14, #15 and #16 and carries the whole feature area
from the fork's beta (the pro-storage branch), rebuilt on top of main (0.1.5, ac4c483) as a reviewable series
of 10 commits, one per part. Nothing else from the fork is in it: no CPU speed, no WiFi list, no cover-matching work,
no Bluetooth (a separate PR), and System update still installs PaddleStroke/RetroStoneOS releases.

RetroStoneOS never ships any game or game data. ports/ holds build scripts and code patches only. A port's
data is always made from the player's own ROM: on a PC with the scripts in ports/, or on the console by the game
store, which finds the ROM on the card or a USB drive and prepares the data locally. Nothing derived from a ROM is
ever downloaded or uploaded.

What it does, commit by commit

  1. Native games (host_launch_native() in frontend/src/host/launch.c, the system native, roms/native):
    one launch script (.sh) per game, run by /bin/sh in its own folder and process group with the display, sound
    and pads handed over as for a libretro game. HOME on /data, SDL_VIDEODRIVER=kmsdrm, SDL_AUDIODRIVER=alsa,
    RSOS_GAME_DIR, RSOS_LANG, output in game.log. Select+Start held 1 s quits it (SIGTERM to the group,
    SIGKILL after HANG_KILL_MS), sleep stops the group and turns the backlight off, power-off sends SIGTERM, the
    idle power-off waits while it runs, an error exit is shown. USB import and the network upload know the folder.
    SDL2 (KMS/DRM, GLES2, ALSA) in the RetroStone2 configs. docs/native-games.md; check-frontend steps 2a-2c.
  2. rsos-gamepad (board/retrostone2/tools/rsos-gamepad.c, built in post-build, CONFIG_INPUT_UINPUT=y): the
    three evdev devices of the built-in controls merged into one uinput gamepad with an SDL mapping, for games that
    read a single SDL game controller (the libultraship ports).
  3. Six N64 PC ports (ports/): Super Mario 64 (sm64-port), Star Fox 64 (Starship), Ocarina of Time (Ship of
    Harkinian 9.3.1), Mario Kart 64 (SpaghettiKart), Majora's Mask (2Ship2Harkinian), GoldenEye 007 (Project Midas).
    Build scripts, patches (a GLES2 mode for libultraship and for the fast3d renderer, 32-bit ARM fixes) and launch
    scripts; ports/README.md explains the steps and which N64 ports can run on a Mali-400 at all. The libraries
    they need are added to the RetroStone2 defconfigs: Ogg/Vorbis, Opus/opusfile, libzip, tinyxml2, spdlog,
    nlohmann-json, SDL2_net.
  4. Controllers: "Configure a controller" first asks the pad kind (SNES/Xbox/PlayStation/Switch or similar,
    Nintendo 64, GameCube); only A, B and Start are required, other steps can be skipped. Built-in profiles for the
    Switch Online N64/NES/Genesis pads, standard-following drivers skip the database, N64 and GameCube pads come out
    of the SDL database by name. Z+Start (and Home/Guide/PS) for pads without Select. "Forget my set-up". Native
    games get every pad's resolved mapping (SDL_GAMECONTROLLERCONFIG_FILE), and each port has a
    <launch script>.layout (ports/*/*.layout) so a real N64 pad plays like the built-in buttons in that game.
    make check-input covers it.
  5. One Ports list, as you asked: Doom, Cave Story and the native games are a single "Ports" system (its own
    theme folder in rsos-dark and rsos-light). A game starts as the system it belongs to (systems_effective():
    .sh native, .exe Cave Story, else Doom), so cores, saves, covers, Rename and the core choice are what they
    were; favorites and play time move to "ports" when the database is read. The folders on the card do not change.
  6. Ports follow HDMI like every libretro game: a Buildroot patch for SDL2's KMSDRM driver
    (board/retrostone2/patches/sdl2/0001-kmsdrm-output-policy.patch) applies the menu's output policy (HDMI when
    plugged in, else the panel, live), renders into a fixed 640x480 surface scaled by the display engine, keeps the
    non-blocking page flip, and moves the sound to the HDMI card with the picture. The policy is also plain C in
    frontend/src/follow/policy.[ch] with a host test. docs/display-design.md section 9b.
  7. Game store helper: rsos-store (list, get, remove, remove-path, find-rom, install-port) downloads from a
    signed catalog (Ed25519 signature on the catalog, size + SHA-256 on every download, safe tar/zstd unpacking) and
    prepares ports from the player's ROM in a guarded child (memory floor, time limit, cancel, atomic commit, install
    record). rsos-mkupdate signfile/verifyfile and scripts/store/make-catalog.py build and sign a catalog.
    store_test.sh runs in make check-update.
  8. Settings > Game store (ui/store_ui.c): the catalog by system, install/update/remove with progress, the
    ROM search for a port ("Your ROM: ..." or "Needs your own ROM ... LOOK AGAIN"), clear errors; "Delete this game"
    on a store-installed port removes the whole port (saves and settings stay). make check-ui drives it with
    tests/fake-rsos-store.sh. docs/store-design.md, docs/store-ports.md, screenshots.
  9. rsos.pot regenerated (make pot): the new and changed messages, plus the usual #: line-reference churn.
  10. Tests brought up to date for the Ports list and the store (below).

The store's catalog and key: you will probably want your own

As in the fork, the build default is the fork's catalog:
STORE_URL = https://raw.githubusercontent.com/KurdtNervanna/RetroStoneOS-Store/main/catalog.json and
frontend/assets/store.pub is the public key of that catalog's signing key (the secret half is not in any
repository). Both are build options: make RSOS_STORE_URL=... RSOS_STORE_PUBKEY=... (frontend/update.mk) builds
against another catalog, and a player can point their console at their own (<state>/store.ini: url=,
allow_http=1). If you would rather host the catalog under PaddleStroke, generate a key with
rsos-mkupdate keygen, replace store.pub, set the URL, and sign with make-catalog.py; I am happy to change the
default in this PR, or to leave the screen hidden (it only shows when rsos-store is installed).

System update is not touched: it still installs PaddleStroke/RetroStoneOS releases with your update key.

Tested

On a PC (WSL Ubuntu), on this branch:

  • cd frontend && make check: passes in full (check-display, -host, -power, -transfer, -ui, -ui-assets, -loader,
    -splash, -board, -i18n, -frontend incl. the native-game steps 2a-2c, -update incl. store_test.sh 73/73,
    -b2, -robust, -input).
  • Each intermediate commit builds (make all mkupdate) and passes check-input and check-loader on its own.
  • tests/test_follow_policy.c (not wired into make, as on the fork): built with gcc and passes.
  • release-defconfig-test.sh, board-sh-test.sh, bt-test.sh, boot-ok-test.sh, scripts/ci/check-defconfigs.sh: pass.
  • Not run: shellcheck (not installed on the test machine), the qemu boot tests (U-Boot host tools download from
    ftp.denx.de fails, the known CI issue), a Buildroot image build.

The last commit fixes three checks that the fork's beta never ran green, because its check-ui stopped at an
earlier test: check-transfer and check-b2-unit did not know the one Ports list yet, and two game-store check-ui
expectations could never match.

On hardware, from the fork's beta builds with the same code, as recorded in its commits and the port READMEs (not
re-verified on this branch): all six ports start and play (each README gives its speed), a Retrolink N64 pad
(0079:0006) works through the wizard, Star Fox 64 installs through the store from the player's ROM, and a store
port can be deleted and reinstalled with its settings kept. The HDMI and sound switching shipped in beta builds
0.1.5.23 and 0.1.5.28.

Not tested on hardware

  • This exact branch has not been flashed: it is the beta's code minus the fork-only features, rebuilt on 0.1.5.
  • A GameCube pad or adapter, and the Switch Online NES/Genesis profiles (logic covered by make check-input only).
  • Store installs of ports other than Star Fox 64 have not all been repeated on hardware (their extractors were
    measured on the console by hand, docs/store-ports.md).
  • Building the ports against this branch's Buildroot output (they were built against the fork's).
  • The board script CI job: scripts/ci/uboot-host-tools.sh cannot download U-Boot from ftp.denx.de at the moment
    (upstream CI issue, not touched here).

Things you may want to change

  • Size: ~14.8k added lines, of which ~6.4k are the ports' patches and build scripts and ~2.2k the store helper.
  • The store points at the fork's catalog and key by default (above).
  • A few docs still speak of the fork's build numbers (ports/README.md: "build 20 or newer", "0.1.5.23/24/28";
    docs/store-*.md: fork builds, the fork's store repository, Perfect Dark and Smash 64 layouts in
    KurdtNervanna/RetroStone-Ports). Say if you want them reworded for upstream.
  • docs/store-ports.md lists a legal review of distributing the asset-free port binaries as an open question.

🤖 Generated with Claude Code

@KurdtNervanna

Copy link
Copy Markdown
Contributor Author

An update on the open question in the description (holding Select + Start didn't end a native game).

On the same RetroStone2 Pro, now on 0.1.5 (a fork build of 0.1.5 with this PR), holding Select + Start for a second did end a native game. It was a game that has no Select + Start quit of its own, so the menu's check was the only one that could have closed it. frontend.log:

[     3.328] host I: native game 304 started: /data/roms/native/Ocarina of Time.sh
[   66.471] frontend: Select+Start held: asking the native game to quit

On 0.1.4 that line never appeared, and the same logs had buttons the kernel reported held for 30 s. So the earlier failure was most likely the lost button releases that 0.1.5 fixes (#10), not this PR's code.

@PaddleStroke

Copy link
Copy Markdown
Owner

@KurdtNervanna hello! Thanks for the PR. I'm not sure to understand the point of this, I think it is actually redundant with something I made already. Have you seen the RetroStone section that is included in the image? The idea was exactly to have 'native games' writen for the retrostone2. So your PR feels like duplicating the same idea. Let me know if I'm wrong.

@KurdtNervanna

Copy link
Copy Markdown
Contributor Author

I didn't know the best way to organize having some native ports for the retrostone2, i understood that there was the "retrostone" category which were native games, then there was a "doom" category, which is a also a native port which has its own. this is also complicated by the fact that i am only currently porting for retrostone2 hardware only. So while I did the porting process (i'm getting awesome native speeds, perfect dark and oot etc are all running with 0 lag) I figured i'd just throw the PR over to you to get your input on where the best place for these games to live. any suggestions? should I collapse Doom and restrostone and native ports into one list?

@KurdtNervanna

KurdtNervanna commented Nov 6, 2026 •

Copy link
Copy Markdown
Contributor Author

After looking at your implementation a bit more closely, they are not quite the same thing, I think! The RetroStone section runs your VC games as libretro cores built into the image. #14 is the plumbing to start a standalone program from the SD card (an SDL2/GLES2 binary drawing straight to KMS/DRM): it hands over the display, puts the program in its own process group, and handles sleep and quit. PC ports of N64 games (Mario 64, Ocarina of Time, Perfect Dark…) are standalone programs, not libretro cores, and they need data built from the user’s own ROM, so they can’t go into the read-only image or into the VC section.

To keep the menu tidy, I’d rename it “Ports” and keep it next to Doom and Cave Story, which already carry the “Ports” subtitle in systems.c. Merging those two in would mix libretro and standalone launches, but I’m happy to do it if you prefer one list. I’ll also close #16: the game build scripts belong in my separate RetroStone-Ports repo rather than in RetroStoneOS. That leaves #14 (the launcher) and #15 (rsos-gamepad, the built-in controls as one SDL gamepad). But please advise as to what you think makes the most sense to do...

@PaddleStroke

PaddleStroke commented Nov 6, 2026 via email

Copy link
Copy Markdown
Owner

@KurdtNervanna

Copy link
Copy Markdown
Contributor Author

I have completed the "game store", if you own the rom file, you can make a native port of the supported games... they all run really well, some at 60fps. more games to come soon...

@PaddleStroke

Copy link
Copy Markdown
Owner

@KurdtNervanna You didn't update the PR right?
Besides I was thinking about it. And what I think would be best for the user, is that it is entirely transparent for him.

So what would happen is that user has super mario 64 on his RetroStoneOS, in the N64 section. He starts the game. RetroStoneOS detect that it's a game that has a native port. And so before starting the game, the OS prompts the user telling him : "This game has a native port that runs smoothly, do you want to download it and use it instead of the original N64 ROM?". Then if the user select yes, the OS download and install the native game. But it does not appear in Port section. Nor in native section. The OS is just smart, when the user starts the game from the N64 section, it launches the native game instead.

Does that sounds good for you?

@KurdtNervanna

Copy link
Copy Markdown
Contributor Author

Thanks, and sorry for the slow reply. You're right: I haven't updated this PR yet, and its description still reflects the older design.

Your transparent idea sounds good to me. Starting the N64 game and being offered the native port is much easier for users than another menu. Some of it already exists on the fork: there's a game store (signed catalog, Settings > Game store) that downloads a port and builds its data from the user's own ROM. So the "download and install" half is working. What's missing is the "offer it when you start the N64 game, then launch the native one next time" half.

Two things to settle for that flow:

  • The port needs data built from the user's own ROM, so after the user says yes there's a one-time build step. The prompt should say so.
  • Ports differ in controls and saves, so we need to decide whether the N64 game's save and controller settings carry over.

Proposal: keep this PR as the plumbing only (start a standalone program, hand over the display, sleep and quit handling). I'll update its description to say that. Then I'd send the "offer a native port on launch" behaviour as a separate follow-up PR built on the store, in whatever shape you prefer. Does that split work for you?

KurdtNervanna added a commit to KurdtNervanna/RetroStoneOS that referenced this pull request Nov 18, 2026
Compares the fork with the official image, lists what has been sent
upstream (PaddleStroke#14 to PaddleStroke#16), how to switch between the two, and how the fork
is kept in sync. README links to it from the fork notice.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
@PaddleStroke

Copy link
Copy Markdown
Owner

Any update on this ? Let me know when it's ready to review so that I can check. The other 2 PRs can be closed if all is in this one right?

@KurdtNervanna

KurdtNervanna commented Nov 19, 2026 via email

Copy link
Copy Markdown
Contributor Author

@PaddleStroke

Copy link
Copy Markdown
Owner

I mean 14 15 and 16. The 3 "Native games' PR. I think they are outdated compare to your fork? If you could make a single PR for native games so I can review it and get it to merge. If you're unavailable I can ask claude to make a PR from your changes in your fork?

KurdtNervanna and others added 10 commits November 20, 2026 09:56
…ator

The system "native" (roms/native): one launch script per game (.sh), run
by /bin/sh in its own folder and its own process group
(host_launch_native), with the display, sound and pads handed over as for
a libretro game. HOME on /data (the root is read-only), SDL_VIDEODRIVER
kmsdrm, SDL_AUDIODRIVER alsa, RSOS_GAME_DIR, RSOS_LANG; output to
game.log. Select+Start held 1 s quits it (SIGTERM to the group, SIGKILL
after HANG_KILL_MS); sleep stops the group and turns the backlight off;
a power-off sends SIGTERM; the idle power-off waits while it runs (no
save state); an error exit is shown. USB import and the network upload
know the native folder ("nativegames" as a RetroPie-style name).

SDL2 (KMS/DRM, GLES2, ALSA) in the RetroStone2 configs.
docs/native-games.md; check-frontend 2a-2c (the launch and environment,
an error exit, the menu stopping: the group goes too).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The RetroStone2's controls are three evdev devices and SDL does not take
the analog stick for a joystick: a game reading one SDL game controller
(libultraship's ports) sees a fraction of them. rsos-gamepad
(board/retrostone2/tools, built in post-build) merges them into a uinput
"RetroStoneOS Gamepad" (positional buttons, C/Z = stick clicks, D-pad =
hat 0, the stick with the menu's not-fitted rule) and prints its SDL
mapping (--print-mapping); a launch script runs it in the game's process
group and tells SDL to ignore the raw gpio-keys (0x0001/0x0001).
CONFIG_INPUT_UINPUT=y. docs/native-games.md.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Build scripts, patches and launch scripts for native ports that run on
the RetroStone2's GPU (GLES2 on lima) as native games. RetroStoneOS ships
none of them and no game data: each is built on a PC (or prepared on the
console) from the player's own ROM. ports/README.md says how.

- sm64: Super Mario 64 (sm64ex-style build, the RetroStoneOS controls,
  8-byte aligned pool blocks: no SIGBUS)
- starship: Star Fox 64 (Starship), a GLES2 libultraship
- soh: Ocarina of Time (Ship of Harkinian 9.3.1) on GLES2: 32-bit ARM
  texture slot sizes, the pause-screen crash, faster draws and asset lookups
- spaghettikart: Mario Kart 64 (SpaghettiKart) on GLES2
- 2ship: Majora's Mask (2Ship2Harkinian) on GLES2
- goldeneye: GoldenEye 007 (Project Midas) on GLES2

Select+Start quits a port at once; the patches keep their bytes
(.gitattributes for the CRLF lines of the shaders).

The libraries of the libultraship ports in the RetroStone2 configs:
Ogg/Vorbis, Opus/opusfile, libzip, tinyxml2, spdlog, nlohmann-json,
SDL2_net.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…r port

Configure a controller first asks what kind of pad it is (SNES, Xbox,
PlayStation, Switch or similar; Nintendo 64; GameCube) and the wizard then
asks for that pad's own buttons. Only A, B and Start are required: a step
is skipped by pressing a button already set or by waiting 6 s. N64 and
GameCube mappings are saved with their type (the database's names: the
N64 C buttons on the right stick halves, GameCube Z on rightshoulder).
Z + Start (no Select on those pads) and Home / Guide / PS open the in-game
menu and quit a native game. "Forget my set-up (automatic)" drops a pad's
own mapping.

Pads are recognised without set-up: built-in profiles for the Switch
Online N64, NES and Genesis pads (hid-nintendo lays them out its own way);
drivers that follow the Linux gamepad standard (xpad, playstation, sony,
nintendo, hid-steam) skip the database; the SDL database for the rest,
where N64 and GameCube pads and adapters are told by their names. A touch
pad is not a player. The wizard reads a stick push past a third of the
range (an 8-bit stick resting at 128 never got past half).

Native games get every external pad's resolved mapping as SDL lines in
/run/rsos/sdl-controllers.txt (SDL_GAMECONTROLLERCONFIG_FILE). A port's
"<launch script>.layout" (ports/*/*.layout) says which SDL element the
game reads for each N64 function, so a real N64 pad plays like the
built-in buttons in that game; an N64 pad with a generic name is named
"N64 Controller (...)" for games that pick a layout by name.

Tested with make check-input and a Retrolink N64 pad (0079:0006).
docs/input-design.md, docs/native-games.md.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The carousel had Doom, Cave Story and a separate entry for the native
games. As asked upstream, there is now a single "Ports" system even
though it mixes libretro cores and standalone programs: it lists the
games of roms/ports, roms/doom, roms/cavestory and roms/native (also on
the other disks). The folders on the card do not change; USB import and
the network upload name it "Ports".

A game of the list starts as the system it belongs to, by its extension
(systems_effective): .sh as a native game, .exe as Cave Story, else Doom,
so cores, saves and launch scripts are the ones they always were. Game
covers, Rename this game (its covers, saves and states) and the core
choice use that system too. The per-game data of the three (favorites,
play time, core) moves to "ports" when the database is read.

Ports gets its own theme folder (rsos-dark, rsos-light: the console art
and accent Doom's had). tests/test_loader.c covers the merged list.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Native ports run on SDL2's KMSDRM driver, which opened every connected
screen and put a game on the built-in panel whatever was plugged in. The
RetroStone2's SDL2 now takes the decision the libretro host takes
(display.c): HDMI when it is plugged in, else the built-in panel, one
output at a time, HDMI never on the panel's CRTC.

- frontend/src/follow/policy.[ch]: the decision as pure C (host-tested,
  tests/test_follow_policy.c); the patch carries the same code.
- Buildroot patch for SDL2 (board/retrostone2/patches/sdl2): the game
  renders into a fixed 640x480 surface shown on the CRTC's primary plane,
  scaled by the display engine (aspect-fit on HDMI), so the game never
  sees a resolution change. Every few frames SDL checks the connectors:
  unplugging HDMI moves the game to the built-in panel, plugging it in
  moves it back, with the panel's backlight off behind HDMI. After the
  first modeset the usual non-blocking drmModePageFlip is kept (the plane
  keeps its scaling), so the ports run as fast as before. The sound
  follows the picture: SDL's ALSA backend plays on the HDMI sound card
  while the game is on HDMI and on the speaker otherwise (a device the
  game chose itself, or AUDIODEV, is left alone).

Docs: display-design.md section 9b, native-games.md, the patch's README
with SDL's zlib licence notice, and the README's display and docs lists.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
rsos-store (frontend/src/update, built and installed next to rsos-update)
downloads games from a signed catalog: the catalog's signature, then the
size and SHA-256 of each download are checked before anything reaches the
games folders; archives are unpacked safely (plain or zstd tar, no links,
no escaping paths, bounded size). Commands: list, get, remove,
remove-path, find-rom, install-port.

Ports are never downloaded as game data: install-port finds the player's
own ROM by SHA-1 (any byte order, N64 folder or a USB drive) and prepares
the port's data from it on the console, in a guarded extractor child
(memory floor, time limit, cancel), with an atomic commit, a mandatory
clean-up and a per-file install record. Files a delete or a hand install
left behind are moved aside into roms/native/.store-replaced/<id>/; an
install into another roms folder keeps its record in that folder.

Signing: rsos-mkupdate signfile / verifyfile sign and check any file with
the update tooling's signify-compatible Ed25519 keys;
scripts/store/make-catalog.py builds the catalog from entry files (sizes,
SHA-256, unpacked size, licence and source required) and signs it.

The default catalog (STORE_URL) is KurdtNervanna/RetroStoneOS-Store and
assets/store.pub is the public key of its signing key (installed as
/usr/share/rsos/store.pub); make RSOS_STORE_URL=... RSOS_STORE_PUBKEY=...
builds another. <state>/store.ini can set "url=" and "allow_http=1" for
the player's own catalog (a home server); command-line options win.

store_test.sh (make check-update): 73 host checks against a local web
server.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Settings > Game store (shown when rsos-store is installed) lists the
catalog's games by system with what is installed and what has an update;
a game's dialog shows its version, author, licence, size and description,
and installs, updates or removes it, with progress and the helper's
errors in plain words (no network, WiFi or Ethernet; not enough free
space; not enough free memory to prepare a port). A port first looks for
the player's own ROM: "Your ROM: ..." and INSTALL, or "Needs your own ROM:
... Put it in your N64 folder or on a USB drive, then choose LOOK AGAIN";
preparing says how long it takes and runs in the background with its
progress in the list. The idle power-off waits while the store works.

"Delete this game" on a Ports launcher the store installed asks the store
to remove the whole port (its program and the data made from the ROM;
saves and settings stay); other games are deleted as before.

check-ui: the list, install, remove, a full drive, a port with its ROM
found and prepared, no ROM, not enough memory (tests/fake-rsos-store.sh).
docs/store-design.md, docs/store-ports.md (which ports the store can
prepare and why), docs/ui-design.md, screenshots in docs/ui-previews.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…game store)

make pot. New and changed messages: the controller wizard (pad kinds, the
N64 and GameCube steps, forget set-up), the Ports list, a native game's
errors, Settings > Game store. The rest of the diff is the "#:" source
line references moving.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The fork's beta never reached these checks green (its check-ui stopped at
an earlier test), so three were out of date:

- check-transfer: "ports" is the carousel entry that lists the games of
  doom, cavestory and native; USB import and the upload use their own
  folders, so sysmap.c has no "ports" line.
- check-b2-unit: Doom and Cave Story are no longer carousel entries of
  their own; the one Ports entry follows PICO-8.
- check-ui (game store): the helper is called with --out FILE first; an
  expect matches the menu title and the selected label (not its value),
  and is a plain substring (no ".*").

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
@KurdtNervanna KurdtNervanna changed the title Native games: programs built for the console, started without an emulator Native games and Ports: launcher, rsos-gamepad, six N64 ports, one Ports list, N64/GameCube pads, HDMI for ports, game store Nov 20, 2026
@KurdtNervanna

Copy link
Copy Markdown
Contributor Author

@PaddleStroke this is ready for review now. As you asked, it is one PR for native games: #15 and #16 are closed and their content is here, together with the newer work from my fork that belongs to the same feature area (one Ports list, controllers and N64 layouts, ports following HDMI, and the game store).

How I'm organising things from here: my fork is a beta, and I'll send each feature area as one PR you can take or leave. The Bluetooth work is in #19 (it now also replaces #20). Other fork-only features stay in the fork unless you want them.

It's 10 commits, one per part, so you can review them separately. The description covers what was tested, what wasn't tested on hardware, and two things you may want to change: the store's default catalog and key point at my catalog, and a few docs still mention fork build numbers.

🤖 Generated with Claude Code

This branch has not been deployed

No deployments
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

2 participants