Vinland Arcade is a custom Raspberry Pi 4 retro gaming console built around a 7-inch touchscreen, wireless game controllers, and a hand-picked library of classic games.
The goal isn't simply to install an existing retro-gaming package. I want to build a dedicated console with its own Vinland-themed interface, designed to boot directly into the game library without exposing the Raspberry Pi desktop or requiring a keyboard and mouse during normal use.
The system will use established emulators underneath, but the launcher, navigation, game library, artwork, controls, and overall user experience will be built specifically for this project.
The first version of Vinland Arcade will be designed to:
Boot directly into the Vinland Arcade interface
Run classic NES and Super Nintendo games
Use a small, curated game library rather than hundreds of games
Navigate using either the touchscreen or game controller
Support two-player games on a single console
Use wireless 2.4 GHz controllers with dedicated USB receivers
Display game artwork and information in a visual game-selection interface
Track favorites, ratings, and number of times games have been played
Return from a game to the Vinland Arcade launcher using the controllers
Include protected system controls for rebooting and shutting down the Raspberry Pi
Keep controller and display latency as low as possible
Operate without an Internet connection once configured
I've built a RetroPie-based system before, and while it worked, I experienced enough controller lag that it affected gameplay.
This time I'm approaching the project differently.
Instead of beginning with a large preconfigured retro-gaming system, I'm starting with Raspberry Pi OS and building upward, adding only the components the console actually needs. Input latency will be tested early in the build rather than discovered after everything else is finished.
The goal is a small game console that feels like an appliance: turn it on, pick a game, and play.
I'm also designing the project with a future second console in mind.
Eventually, I would like to build two Vinland Arcade stations capable of playing compatible multiplayer games against each other over a local network.
Network play will not be part of the first build. The standalone system needs to be responsive and reliable first. Once that is accomplished, a second unit can be built and network multiplayer tested, beginning with wired Ethernet before experimenting with Wi-Fi.
Vinland Arcade is being built around a Raspberry Pi 4 Model B. The hardware is intentionally simple. The Raspberry Pi handles the launcher and emulation, while a touchscreen provides the display and system interface and dedicated wireless controllers handle gameplay.
Raspberry Pi 4 Model B
The Pi 4 will run Raspberry Pi OS 64-bit, the Vinland Arcade launcher, and the NES/SNES emulators. I already had this Raspberry Pi available from other projects.
7-inch Raspberry Pi Touchscreen
The touchscreen connects directly to the Raspberry Pi and serves two purposes. It is the game display, but it also allows Vinland Arcade's menus and system controls to be operated without a keyboard or mouse.
64 GB PNY microSDXC Card
A dedicated 64 GB card is being used for Vinland Arcade. This keeps the entire game-console installation separate from my other Raspberry Pi projects.
The card contains the operating system, Vinland Arcade software, emulator configuration, game artwork, and the curated game library.
ZAMPAM 2.4 GHz Wireless Gamepads, 2-Pack
The controllers use dedicated 2.4 GHz USB wireless receivers rather than Bluetooth. They have an SNES-style layout with a directional pad, A/B/X/Y buttons, Start and Select.
Both controllers will be tested individually and simultaneously before the rest of the console is completed. Because input lag was a problem with one of my previous retro-gaming builds, controller latency is an important part of this project.
Official Raspberry Pi USB-C 5V / 3A Power Supply
Using a properly sized Raspberry Pi power supply helps eliminate power instability as a possible source of crashes, USB problems, or inconsistent performance.
The finished system will also use:
Raspberry Pi touchscreen-compatible enclosure
USB receivers for both wireless controllers
microSD card reader for initial setup
Wi-Fi for setup, updates, and future expansion
Ethernet available for future head-to-head testing
Rather than installing a complete retro-gaming distribution such as RetroPie, Vinland Arcade starts with a standard installation of Raspberry Pi OS 64-bit with Desktop.
From there, I will add only the pieces needed for the console.
The software will be divided into three basic layers:
Raspberry Pi OS → Vinland Arcade Launcher → Emulators
The custom Vinland Arcade launcher will be what the player normally sees. The emulator software underneath will handle the actual NES and Super Nintendo games.
The first version of the software will include:
Custom full-screen Vinland Arcade interface
NES and SNES emulation
Touchscreen and controller navigation
Game artwork and information
Favorites
Game ratings
Play counters
Two-player local gaming
Controller shortcut to exit a game and return to Vinland Arcade
Idle/attract mode
Protected administrative menu
Restart, reboot, and shutdown controls
Automatic startup when the Raspberry Pi boots
Two ideas are deliberately being saved for later.
Leaderboards: I only want to add high-score leaderboards if scores can be captured automatically and reliably from the games. Manually entering scores would defeat much of the purpose.
Network Head-to-Head: The software will be designed with future network multiplayer in mind, but the first machine will be completed and latency-tested before a second Vinland Arcade is introduced.
Vinland Arcade uses a dedicated 64 GB microSD card. Keeping the arcade installation on its own card allows the same Raspberry Pi hardware to be used for other projects simply by changing microSD cards.
For this build I am using Raspberry Pi Imager on a Windows computer to install Raspberry Pi OS 64-bit with Desktop.
In Raspberry Pi Imager:
Select Raspberry Pi 4 as the device.
Select Raspberry Pi OS (64-bit) with Desktop as the operating system.
Select the 64 GB microSD card as the storage device.
Configure a username and password.
Enable SSH using password authentication.
Configure an available Wi-Fi network for the initial setup.
Set the time zone to America/Chicago.
Set the keyboard layout to US.
Write the operating system to the card and allow Raspberry Pi Imager to complete its verification.
I prepared the microSD card while away from the location where Vinland Arcade will normally operate, so Raspberry Pi Imager was configured with my mobile Starlink Wi-Fi connection.
This is only being used to establish the Raspberry Pi's initial network connection.
Once the system is installed at Vinland Meads, the Vinland Meads Wi-Fi network will also be added. Raspberry Pi OS can remember multiple Wi-Fi networks and automatically connect to a known network when it is available.
Wi-Fi passwords are not stored in the project documentation or source code.
SSH was enabled while creating the microSD card. This allows most of the remaining software installation and configuration to be performed remotely from a Windows laptop rather than requiring a keyboard and mouse connected to the arcade.
Windows 10 and Windows 11 include an SSH client, so no additional remote-access software is required for the initial build.
With the Raspberry Pi powered off:
Insert the 64 GB Vinland Arcade microSD card.
Connect the 7-inch touchscreen.
Connect one wireless controller's 2.4 GHz USB receiver.
Connect the Raspberry Pi power supply.
Turn on the controller.
Power on the Raspberry Pi.
Allow several minutes for Raspberry Pi OS to complete its first startup and connect to Wi-Fi.
On the Windows laptop, open Windows Terminal or PowerShell.
The card currently has the temporary hostname:
id-scanner
Connect with:
ssh scanner@id-scanner.local
The first connection may display a message stating that the authenticity of the host cannot be established.
When asked:
Are you sure you want to continue connecting?
enter:
yes
Then enter the password that was created in Raspberry Pi Imager.
The password does not appear on the screen while it is being typed. This is normal.
A successful connection should produce a command prompt similar to:
scanner@id-scanner:~ $
At this point the Raspberry Pi can be configured remotely from the laptop.
The microSD card inherited the hostname id-scanner from another Raspberry Pi project. Vinland Arcade needs its own permanent network name.
Run:
sudo raspi-config
Select:
System Options → Hostname
Change the hostname from:
id-scanner
to:
pi-arcade
Exit Raspberry Pi Configuration and reboot:
sudo reboot
The SSH connection will close while the Raspberry Pi restarts.
Wait approximately one minute and reconnect from the Windows laptop:
ssh scanner@pi-arcade.local
Verify the new hostname:
hostname
The result should be:
pi-arcade
Then obtain the Raspberry Pi's current local IP address:
hostname -I
I record this address during the build as a backup method of connecting to the Raspberry Pi if .local hostname discovery is ever unavailable.
When Vinland Arcade is moved to its normal location, use Raspberry Pi OS to connect it to the Vinland Meads Wi-Fi network.
The password is entered directly into Raspberry Pi OS and is not included in this build documentation.
After the network has been saved, the Raspberry Pi can automatically reconnect whenever that network is available.
Before continuing:
✓ Raspberry Pi OS boots
✓ 7-inch touchscreen works
✓ Raspberry Pi connects to Wi-Fi
✓ SSH works from the Windows laptop
✓ Hostname has been changed to pi-arcade
✓ Local IP address has been recorded
✓ Vinland Meads Wi-Fi will be added on location
Step 1 complete.
Before installing the emulators or Vinland Arcade software, I want the Raspberry Pi operating system completely updated and its basic configuration verified.
Doing this now gives the project a known starting point and helps prevent an outdated package or operating-system component from causing problems later.
From the Windows laptop, open Windows Terminal or PowerShell and connect to the Raspberry Pi:
ssh scanner@pi-arcade.local
After entering the password, the prompt should look similar to:
scanner@pi-arcade:~ $
First, download the current package information:
sudo apt update
When that finishes, install all available operating-system updates:
sudo apt full-upgrade -y
Depending on the number of available updates and the Internet connection, this may take several minutes.
After the upgrade finishes, clean up packages that are no longer required:
sudo apt autoremove -y
Then clean the local package cache:
sudo apt clean
Restart the Raspberry Pi so any kernel, firmware, or system updates are loaded:
sudo reboot
The SSH connection will automatically close.
Wait for the Raspberry Pi to restart, then reconnect:
ssh scanner@pi-arcade.local
Now I want to record exactly what Vinland Arcade is running.
Check the Raspberry Pi OS version:
cat /etc/os-release
This will display information including the Raspberry Pi OS/Debian version.
Next check the Linux kernel:
uname -a
Check the Raspberry Pi model:
cat /proc/device-tree/model
The result should identify the hardware as a Raspberry Pi 4 Model B.
Run:
uname -m
For the 64-bit operating system, I expect:
aarch64
Because this build uses a 64 GB card, I also want to verify that Raspberry Pi OS can see the available storage:
df -h /
This shows the size of the root filesystem, how much space is currently being used, and how much remains available for the arcade software, artwork and game library.
Run:
free -h
This records the amount of RAM available to the system and gives me another useful baseline before installing the emulation software.
Before changing anything related to graphics, I verify that the 7-inch touchscreen is operating normally.
At this point:
Raspberry Pi OS should fill the display correctly.
The image should be properly oriented.
Touch input should correspond to the correct location on the screen.
There should be no obvious flickering or display instability.
I am deliberately not changing resolution, scaling, refresh rate, GPU settings, or performance settings yet.
The stock configuration gives me a baseline. Later, if gameplay shows latency or performance problems, I can make one change at a time and measure whether it actually improves the system.
For future troubleshooting, I record the results of:
Raspberry Pi OS Version:
Kernel Version:
Architecture:
Raspberry Pi Model:
Installed RAM:
Available Storage:
This makes it possible to identify exactly what hardware and software configuration was used when Vinland Arcade was originally built.
Before continuing:
✓ Raspberry Pi OS is fully updated
✓ Unneeded packages have been removed
✓ System has been rebooted
✓ Hostname remains pi-arcade
✓ Raspberry Pi 4 is correctly identified
✓ Operating system is running 64-bit
✓ Storage is correctly detected
✓ RAM is correctly detected
✓ 7-inch display operates normally
✓ Touchscreen responds correctly
Step 2 complete.
Vinland Arcade uses two ZAMPAM 2.4 GHz wireless game controllers. Each controller communicates through a dedicated USB wireless receiver rather than Bluetooth.
Because controller lag was one of the biggest problems with my previous Raspberry Pi gaming system, I am testing the controllers before installing or configuring the emulators.
This establishes whether Linux is receiving controller input correctly before additional software is introduced.
With the Raspberry Pi running, plug the first controller's USB receiver into one of the Raspberry Pi's USB ports and turn on the controller.
From the remote SSH connection, check the connected USB devices:
lsusb
The wireless receiver should appear as a USB input or HID device. It may not necessarily identify itself using the ZAMPAM brand name.
Run:
ls /dev/input/
Linux should display several input devices.
Look for a joystick device such as:
js0
To specifically display joystick devices:
ls -l /dev/input/js*
With one controller connected, I expect to see:
/dev/input/js0
Install the Linux joystick testing tools:
sudo apt install joystick -y
Then test Controller 1:
jstest /dev/input/js0
The terminal will display the controller's axes and buttons.
I test:
D-Pad Up
D-Pad Down
D-Pad Left
D-Pad Right
A
B
X
Y
Start
Select
Left Shoulder
Right Shoulder
Each control should cause an immediate change in the values displayed by jstest.
Press:
Ctrl+C
to exit the test.
I also want to record exactly how Linux identifies these controllers.
Run:
cat /proc/bus/input/devices
Look for the section associated with the game controller.
It should contain information similar to:
N: Name="USB Gamepad"
H: Handlers=eventX js0
The actual name will depend on the USB receiver.
This information will become useful when the Vinland Arcade launcher needs to recognize the controllers automatically.
Now connect the second ZAMPAM USB receiver and turn on Controller 2.
Run:
ls -l /dev/input/js*
With both controllers connected, I expect something similar to:
/dev/input/js0
/dev/input/js1
Test Controller 2:
jstest /dev/input/js1
Again test the D-pad, face buttons, shoulder buttons, Start and Select.
Exit with:
Ctrl+C
Linux recognizing two controllers is not enough. I also want to verify that each receiver remains associated with its own controller.
Open two SSH/Terminal windows from the laptop.
In the first:
jstest /dev/input/js0
In the second:
jstest /dev/input/js1
Operate Controller 1 only.
Only the js0 window should respond.
Then operate Controller 2 only.
Only the js1 window should respond.
This verifies that both controllers can operate simultaneously as independent Player 1 and Player 2 devices.
At this stage I also record which Linux button number corresponds to each physical control.
For example:
Physical Control Linux Input
---------------------------------
A Button ?
B Button ?
X Button ?
Y Button ?
Start Button ?
Select Button ?
Left Shoulder Button ?
Right Shoulder Button ?
D-Pad Axis ?
I do not fill these numbers in ahead of time.
They will be taken directly from jstest because inexpensive USB gamepads do not always report their buttons in the order printed on the controller.
That mapping will later be used when configuring the emulator and our custom launcher.
This test confirms that the controllers are recognized and their inputs reach Linux.
It does not yet prove that the finished console has acceptable input latency.
There are several places where latency can be introduced:
Controller
↓
2.4 GHz Receiver
↓
Linux Input
↓
Emulator
↓
Video Rendering
↓
Display
For that reason I am not changing controller drivers, graphics settings, shaders, frame synchronization, or other performance options yet.
Once a game is running, I will test actual gameplay response and make changes only if necessary.
Before continuing:
✓ Controller 1 receiver detected
✓ Controller 1 appears as a joystick
✓ D-pad works
✓ A/B/X/Y work
✓ Start and Select work
✓ Shoulder buttons work
✓ Controller 2 receiver detected
✓ Controller 2 appears as a separate joystick
✓ Controller 2 controls work
✓ Both controllers operate simultaneously
✓ Linux button mappings have been recorded
Step 3 complete.
Vinland Arcade will use RetroArch and libretro cores underneath the custom Vinland interface.
I am not installing RetroPie or EmulationStation. RetroArch will handle the actual emulation, while the Vinland Arcade software will handle game selection, artwork, touchscreen controls, controller navigation, favorites, ratings, launching games and returning to the main interface.
During normal use, the player should never need to interact directly with RetroArch.
From Windows Terminal or PowerShell:
ssh scanner@pi-arcade.local
Refresh the package list:
sudo apt update
Install RetroArch:
sudo apt install retroarch -y
Verify the installation:
retroarch --version
A RetroArch version number should be displayed.
For NES games, Vinland Arcade will initially use the FCEUmm libretro core.
Install it with:
sudo apt install libretro-fceumm -y
For Super Nintendo games, Vinland Arcade will initially use Snes9x 2010.
Install it with:
sudo apt install libretro-snes9x2010 -y
This core is lightweight and should run well on a Raspberry Pi 4. If later testing shows compatibility or latency issues, another SNES core can be substituted without changing the overall Vinland Arcade design.
Run:
find /usr/lib -type f \( -name "*fceumm*.so" -o -name "*snes9x*.so" \) 2>/dev/null
This should display the installed core files.
Record the paths shown by this command. The exact installation directory can vary between Raspberry Pi OS versions, so the launcher will use the paths actually present on the machine rather than relying on assumptions.
Create the main project folder:
mkdir -p ~/vinland-arcade
Create the subdirectories:
mkdir -p ~/vinland-arcade/{launcher,config,roms/nes,roms/snes,artwork/nes,artwork/snes,data,logs,scripts}
Verify the structure:
find ~/vinland-arcade -maxdepth 2 -type d | sort
The directory structure should resemble:
vinland-arcade/
│
├── artwork/
│ ├── nes/
│ └── snes/
│
├── config/
├── data/
├── launcher/
├── logs/
│
├── roms/
│ ├── nes/
│ └── snes/
│
└── scripts/
The folders will be used as follows:
launcher
Contains the custom Vinland Arcade interface.
config
Contains Vinland Arcade and RetroArch configuration files.
roms/nes
Contains selected NES game files.
roms/snes
Contains selected Super Nintendo game files.
artwork
Contains box art and other graphics used by the launcher.
data
Stores favorites, ratings, play counts and other launcher information.
logs
Stores diagnostic and error information.
scripts
Contains game-launch and system-control scripts.
Create the configuration file:
touch ~/vinland-arcade/config/retroarch.cfg
Open it:
nano ~/vinland-arcade/config/retroarch.cfg
Paste:
video_fullscreen = "true"
video_windowed_fullscreen = "false"
audio_enable = "true"
input_autodetect_enable = "true"
menu_enable_widgets = "false"
savestate_auto_save = "false"
savestate_auto_load = "false"
rewind_enable = "false"
video_shader_enable = "false"
run_ahead_enabled = "false"
Save with:
Ctrl+O
Enter
Ctrl+X
At this stage, I am intentionally leaving features such as:
shaders
rewind
run-ahead
frame-delay tuning
video filters
complicated scaling
aggressive latency settings
disabled.
The goal is to establish a clean baseline first. If gameplay later shows latency or performance problems, I can change one setting at a time and see whether it actually improves the system.
The full curated library will be added later.
For the first emulator test, I only need:
ONE NES GAME
ONE SNES GAME
Those test ROMs will go into:
/home/scanner/vinland-arcade/roms/nes/
and:
/home/scanner/vinland-arcade/roms/snes/
This keeps the first test simple and makes troubleshooting much easier.
Before continuing:
✓ RetroArch installed
✓ NES core installed
✓ SNES core installed
✓ Core paths identified
✓ Vinland Arcade project directory created
✓ NES and SNES ROM folders created
✓ Artwork folders created
✓ Data and log folders created
✓ Dedicated RetroArch configuration created
✓ Performance-altering features left disabled
✓ Full game library not loaded yet
Now that RetroArch and the NES/SNES emulator cores are installed, Vinland Arcade needs a simple way to launch games without requiring the player to interact with RetroArch.
This step creates the bridge between the future Vinland Arcade interface and the emulator.
The finished process will work like this:
Vinland Arcade
↓
Player selects a game
↓
Launcher identifies NES or SNES
↓
Correct emulator core is selected
↓
RetroArch opens fullscreen
↓
Game runs
↓
Player exits the game
↓
RetroArch closes
↓
Vinland Arcade returns
For now, I am building and testing that process from the command line. The graphical Vinland Arcade interface will use the same launch system later.
Before creating the launch script, confirm the exact location of the emulator cores:
find /usr/lib -type f \( -name "*fceumm*.so" -o -name "*snes9x2010*.so" \) 2>/dev/null
The output should show paths for both cores.
They may resemble:
/usr/lib/aarch64-linux-gnu/libretro/fceumm_libretro.so
/usr/lib/aarch64-linux-gnu/libretro/snes9x2010_libretro.so
Use the paths actually displayed on the Raspberry Pi.
Do not assume they will exactly match the example above.
Create the launch script:
nano ~/vinland-arcade/scripts/launch-game.sh
Paste the following:
#!/bin/bash
set -u
ARCADE_HOME="$HOME/vinland-arcade"
CONFIG="$ARCADE_HOME/config/retroarch.cfg"
LOG="$ARCADE_HOME/logs/launcher.log"
ROM="${1:-}"
SYSTEM="${2:-}"
timestamp() {
date '+%Y-%m-%d %H:%M:%S'
}
log_message() {
printf '[%s] %s\n' "$(timestamp)" "$1" >> "$LOG"
}
if [ -z "$ROM" ] || [ -z "$SYSTEM" ]; then
echo "Usage: $0 /path/to/game.rom nes|snes"
exit 1
fi
if [ ! -f "$ROM" ]; then
echo "Game file not found:"
echo "$ROM"
log_message "ERROR: ROM not found: $ROM"
exit 1
fi
if [ ! -f "$CONFIG" ]; then
echo "RetroArch configuration not found:"
echo "$CONFIG"
log_message "ERROR: RetroArch configuration missing."
exit 1
fi
case "$SYSTEM" in
nes)
CORE=$(find /usr/lib -type f -name "fceumm_libretro.so" 2>/dev/null | head -n 1)
;;
snes)
CORE=$(find /usr/lib -type f -name "snes9x2010_libretro.so" 2>/dev/null | head -n 1)
;;
*)
echo "Unsupported system: $SYSTEM"
log_message "ERROR: Unsupported system: $SYSTEM"
exit 1
;;
esac
if [ -z "$CORE" ] || [ ! -f "$CORE" ]; then
echo "Emulator core could not be found for: $SYSTEM"
log_message "ERROR: Core not found for $SYSTEM"
exit 1
fi
log_message "Launching $SYSTEM game: $ROM"
retroarch \
--config "$CONFIG" \
-L "$CORE" \
"$ROM"
EXIT_CODE=$?
log_message "Game closed: $ROM (RetroArch exit code $EXIT_CODE)"
exit "$EXIT_CODE"
Save:
Ctrl+O
Enter
Ctrl+X
Linux needs permission to execute the file as a program.
Run:
chmod +x ~/vinland-arcade/scripts/launch-game.sh
Verify:
ls -l ~/vinland-arcade/scripts/launch-game.sh
The permissions should contain an x, indicating that the script is executable.
The launcher receives two pieces of information:
GAME FILE
SYSTEM
For example:
Super Mario Bros. 3
NES
The script then finds the NES emulator core and starts RetroArch using that core.
For a Super Nintendo game, it selects the SNES core instead.
This means the future graphical launcher does not need separate emulator logic scattered throughout the program. It only needs to tell this script which game to play and which system it belongs to.
Place one legally obtained NES ROM in:
/home/scanner/vinland-arcade/roms/nes/
For example, if the file were named:
test-game.nes
the complete path would be:
/home/scanner/vinland-arcade/roms/nes/test-game.nes
To see the games currently in the folder:
ls -lh ~/vinland-arcade/roms/nes/
Place one legally obtained SNES ROM in:
/home/scanner/vinland-arcade/roms/snes/
For example:
test-game.sfc
Check the folder:
ls -lh ~/vinland-arcade/roms/snes/
Common SNES ROM extensions include:
.sfc
.smc
From SSH, enter:
~/vinland-arcade/scripts/launch-game.sh "$HOME/vinland-arcade/roms/nes/test-game.nes" nes
Replace test-game.nes with the actual filename being used.
RetroArch should open on the Raspberry Pi touchscreen and launch the game directly.
The laptop's SSH window is only issuing the command. The game itself appears on the Raspberry Pi display.
Run:
~/vinland-arcade/scripts/launch-game.sh "$HOME/vinland-arcade/roms/snes/test-game.sfc" snes
Again, replace the example filename with the actual ROM filename.
The SNES game should launch directly.
Every launch attempt is recorded in:
/home/scanner/vinland-arcade/logs/launcher.log
View it with:
cat ~/vinland-arcade/logs/launcher.log
A successful test should produce entries similar to:
[2026-09-14 19:14:03] Launching nes game: /home/scanner/vinland-arcade/roms/nes/test-game.nes
[2026-09-14 19:20:17] Game closed: /home/scanner/vinland-arcade/roms/nes/test-game.nes (RetroArch exit code 0)
This logging will be useful later if a game fails to launch from the graphical interface.
Eventually I want:
START + SELECT
↓
EXIT GAME
↓
RETURN TO VINLAND ARCADE
But I am not configuring that shortcut in this step.
First I want to confirm that both emulator cores launch correctly and that both controllers operate normally inside actual games.
Controller hotkeys will get their own step so they can be tested without mixing controller configuration problems with emulator-launch problems.
Before continuing:
✓ Game-launch script created
✓ Script is executable
✓ NES core is selected automatically
✓ SNES core is selected automatically
✓ Missing games produce an error instead of crashing
✓ Launch attempts are logged
✓ One NES test game launches fullscreen
✓ One SNES test game launches fullscreen
✓ Closing RetroArch returns control to the command line
Linux can now see both ZAMPAM 2.4 GHz wireless controllers, and the launch system can start NES and SNES games.
The next step is configuring the controllers inside RetroArch.
The goals for this step are:
Controller 1 operates Player 1
Controller 2 operates Player 2
NES and SNES controls feel natural
Both controllers work simultaneously
Start + Select exits the current game
Exiting RetroArch returns control to Vinland Arcade
This is also our first opportunity to see how the wireless controllers actually feel during gameplay.
For the initial configuration, I connect only Controller 1 and its USB receiver.
From SSH, verify that it is still detected:
ls -l /dev/input/js*
With one controller connected, I should see:
/dev/input/js0
RetroArch includes controller autoconfiguration support.
Launch RetroArch by itself:
retroarch --config ~/vinland-arcade/config/retroarch.cfg
RetroArch should appear on the Raspberry Pi touchscreen.
Using the controller, check whether the D-pad can navigate the RetroArch interface and whether the face buttons select and return through menus.
If the controller is automatically recognized and mapped correctly, I do not manually remap it simply for the sake of changing something.
A working automatic configuration gives me a cleaner baseline.
If RetroArch recognizes the controller but the buttons are incorrect, use the RetroArch interface:
Settings → Input → RetroPad Binds → Port 1 Controls
The exact wording can vary slightly by RetroArch version.
Map the physical controls:
D-Pad Up
D-Pad Down
D-Pad Left
D-Pad Right
A
B
X
Y
Start
Select
L
R
Save the configuration before exiting RetroArch.
Because the controllers use an SNES-style physical layout, the goal is for the controls to feel natural rather than simply matching arbitrary Linux button numbers.
After Controller 1 works correctly, connect the second USB receiver and turn on Controller 2.
Verify both controllers:
ls -l /dev/input/js*
I should now see:
/dev/input/js0
/dev/input/js1
Launch RetroArch again:
retroarch --config ~/vinland-arcade/config/retroarch.cfg
Check:
Settings → Input → RetroPad Binds → Port 2 Controls
Controller 2 should be assigned to Port 2.
I want patrons to be able to leave a game without seeing emulator menus or reaching for a keyboard.
The planned combination is:
SELECT + START
Rather than assigning a single button to quit, RetroArch can use one button as a Hotkey Enable button and another as the Quit RetroArch button.
That prevents somebody from accidentally closing a game by pressing Start during normal gameplay.
In RetroArch, open:
Settings → Input → Hotkeys
Set:
Hotkey Enable → Select
Quit → Start
The resulting behavior should be:
SELECT held
+
START pressed
↓
RetroArch exits
A normal press of Start should still function as Start inside the game.
A normal press of Select should still function as Select.
Only the combination should exit RetroArch.
The exact button numbers reported by the ZAMPAM controllers may differ from another gamepad.
I therefore configure the hotkeys using the actual controller, rather than assuming Select and Start correspond to particular Linux button numbers.
After the controller and hotkey configuration is working, save the RetroArch configuration.
Use:
Main Menu → Configuration File → Save Current Configuration
Then exit RetroArch.
Because Vinland Arcade uses its own configuration file, I verify that the file still exists:
ls -lh ~/vinland-arcade/config/retroarch.cfg
Launch the NES test game using the launcher created in Step 5:
~/vinland-arcade/scripts/launch-game.sh "$HOME/vinland-arcade/roms/nes/test-game.nes" nes
Replace test-game.nes with the actual filename.
Test:
D-Pad
A
B
Start
Select
The controller should respond immediately and naturally.
Then hold Select and press Start.
RetroArch should close.
The SSH command should finish and control should return to:
scanner@pi-arcade:~ $
That behavior is important because our graphical Vinland Arcade launcher will eventually remain underneath RetroArch.
When the game closes, the player will automatically return to Vinland Arcade.
Launch the SNES test game:
~/vinland-arcade/scripts/launch-game.sh "$HOME/vinland-arcade/roms/snes/test-game.sfc" snes
Replace the filename with the actual SNES test ROM.
Test:
D-Pad
A
B
X
Y
L
R
Start
Select
Then test:
SELECT + START
RetroArch should exit.
Now launch a game that natively supports two players.
Controller 1 should operate Player 1.
Controller 2 should operate Player 2.
I test both controllers simultaneously and watch for:
missed button presses
one controller controlling both players
controllers changing player assignments
delayed input
wireless interference
receiver disconnections
For the first build, local two-player support is part of Vinland Arcade Version 1.
Network head-to-head between two separate Vinland Arcade machines is reserved for a future version.
This is the first point where controller latency can be judged meaningfully.
jstest proved that Linux receives controller input. Now I can see the complete chain:
Controller
↓
2.4 GHz USB Receiver
↓
Linux
↓
RetroArch
↓
Emulator Core
↓
Video Output
↓
7-inch Display
I use a game with immediate, obvious movement or jumping and repeatedly compare the physical button press with the response on screen.
At this stage I am looking for noticeable gameplay lag, not attempting laboratory-grade millisecond measurements.
If the controls feel responsive, I leave the latency settings alone.
If they feel delayed, I stop here and investigate before building the graphical launcher.
RetroArch includes many settings that can affect latency:
Run-Ahead
Frame Delay
VSync
Threaded Video
Audio Latency
Shaders
Video Drivers
Synchronization
I deliberately do not start changing all of these settings.
If baseline gameplay feels good, the baseline stays.
If it doesn't, I will identify the cause and change one variable at a time.
Before continuing:
✓ Controller 1 operates Player 1
✓ Controller 2 operates Player 2
✓ NES controls are correct
✓ SNES controls are correct
✓ Both controllers work simultaneously
✓ Start works normally during gameplay
✓ Select works normally during gameplay
✓ Select + Start exits RetroArch
✓ Exiting returns control to the launcher
✓ Two-player gameplay works
✓ No obvious controller disconnects
✓ Baseline input latency is acceptable
Filename: background_main.png
This is the most important one. No buttons, game covers, titles, or text. Just the environment behind the interface.
Ask me:
Create Graphic #1 for Vinland Arcade: the Main Launcher Background. Make a wide cinematic Viking mead-hall/longhouse interior with dark aged timber, iron details, warm fire and candlelight, subtle Norse atmosphere, and hints of Vinland Meads styling. It needs to work behind a retro-game launcher, so keep the center area relatively dark and uncluttered for game artwork and interface elements. Do not include people, text, buttons, game artwork, Viking helmets, or a logo. This is a reusable UI background, not a finished screen. Make it high resolution and suitable for scaling down to a 5-inch or 7-inch Raspberry Pi display.
Filename: header_vinland_arcade.png
Transparent graphic containing the branding at the top.
Ask me:
Create Graphic #2 for Vinland Arcade: the Vinland Arcade Header. Use the Vinland Meads shield logo I provided as the centerpiece and create the words VINLAND ARCADE in a high-end Viking/Norse carved-metal and aged-wood style that matches the launcher background. Keep the actual Vinland shield accurate. No horned helmets. Transparent background. This needs to be a reusable header graphic for the Raspberry Pi launcher.
For this one, attach the logo again when you ask. That removes any ambiguity about which shield we're using.
Filename: game_frame_selected.png
This sits around the currently selected box cover.
Ask me:
Create Graphic #3 for Vinland Arcade: the Selected Game Frame. Make an ornate rectangular frame for retro-game box artwork using dark carved wood, aged iron and subtle Norse detailing. The center must be completely transparent so the launcher can place different game covers behind it. Make the selected state visually prominent without excessive decoration. No text, logos, game artwork, helmets, or background. Transparent PNG.
Filename: game_frame_normal.png
Used for the smaller games on either side of the selected game.
Ask me:
Create Graphic #4 for Vinland Arcade: the Normal Game Frame. Make a simpler, darker version of the approved Selected Game Frame for unselected game covers in the carousel. Preserve the same proportions and visual family, but make it less prominent than the selected frame. Transparent center and transparent exterior background. No text or game artwork.
Important: When we get here, attach Graphic #3 so I can match it instead of reinventing it.
Filename: button_normal.png
One reusable blank button. The software puts PLAY, FAVORITES, SETTINGS, etc. on top.
Ask me:
Create Graphic #5 for Vinland Arcade: a blank reusable menu button. Make a horizontal Viking-mead-hall button from aged dark wood with an iron border and subtle carved details. It must contain absolutely no text or icons because the launcher will draw its own labels. Transparent background. Make it clean and readable as a touchscreen control.
Filename: button_selected.png
Same exact dimensions as #5, but highlighted for controller navigation/touch selection.
Ask me:
Create Graphic #6 for Vinland Arcade: the Selected Menu Button. Use the approved normal button as the exact design and proportions, but create a clearly highlighted selected/focused state using warmer illumination and stronger edge definition. Do not change its size or basic construction. No text or icons. Transparent background.
Attach #5 when we make it.
Filename: arrow_left.png
Ask me:
Create Graphic #7 for Vinland Arcade: a left navigation arrow. Make a large, simple Viking-themed left arrow using aged iron with subtle carved/Norse detailing. It must remain immediately recognizable as a navigation arrow on a small touchscreen. No text. Transparent background.
Filename: arrow_right.png
We should actually derive this from the approved left arrow rather than independently generating it.
Ask me:
Create Graphic #8 for Vinland Arcade: the right navigation arrow. Use the approved left navigation arrow and make an exact mirrored counterpart. Do not redesign it. Transparent background.
Attach #7.
Filename: icon_settings.png
Ask me:
Create Graphic #9 for Vinland Arcade: the Settings/Admin icon. Make a simple aged-iron gear with subtle Viking styling that remains clearly recognizable as a settings icon at small size. No text, shield, background, or extra decoration. Transparent PNG.
The program will require a 3-second hold on this icon to open Admin, so patrons aren't wandering into Raspberry Pi controls.
Filename: icon_favorite.png
Rather than a generic modern heart, I'd use something that fits the interface but remains obvious.
Ask me:
Create Graphic #10 for Vinland Arcade: the Favorite icon. Create a simple five-point favorite star made from aged gold/bronze metal that matches the Viking mead-hall interface. It must remain recognizable at small size. No text or background. Transparent PNG.
Filename: rating_star.png
This should be simpler than #10 because five of them will appear together.
Ask me:
Create Graphic #11 for Vinland Arcade: the Rating Star. Make a clean, simple five-point aged-gold star designed to appear five times in a small game-rating control. Minimal detail, excellent readability at small size, transparent background, no text.
We can tint/dim the same asset in software for empty stars, so we only need one image.
Filename: background_attract.png
This appears when nobody has touched the machine for a while.
Ask me:
Create Graphic #12 for Vinland Arcade: the Attract Mode Background. Create a cinematic Viking longhouse/mead-hall scene related to the approved main launcher background, with dramatic warm firelight and a slightly more atmospheric presentation. Leave a large clean central area where the software can display rotating game artwork, game titles and PRESS A TO PLAY. Do not include any text, game artwork, buttons, people, horned helmets, or logos. High resolution.
Filename: panel_admin.png
Ask me:
Create Graphic #13 for Vinland Arcade: the Admin Menu Panel. Make a large dark aged-wood panel with an iron border and restrained Norse carving. The interior needs to remain clean and dark because the software will place system controls and text over it. No words, buttons, icons, logos, or background scene. Transparent exterior background.
Filename: launching.png
A short transition hides the desktop/emulator startup ugliness.
Ask me:
Create Graphic #14 for Vinland Arcade: the Launching Game transition graphic. Create a dramatic Vinland Arcade transition screen using a dark Viking mead-hall atmosphere with the Vinland Meads shield as the central visual. Leave room beneath the shield for the software to display LAUNCHING and the selected game's name dynamically. Do not bake any game name or interface text into the image. No people or horned helmets. High resolution.
Attach the real Vinland logo again for this one.
Filename: clyde_barrel.png
Copy/paste this:
Create Graphic #15 for Vinland Arcade: Clyde on His Mead Barrel. Use the attached photo of Clyde as the reference for his appearance. Create a full-body side-view game character of Clyde riding on top of a rolling wooden mead barrel, designed for a hidden Vinland Arcade Easter egg mini-game. Clyde is bald with a full beard and no mustache, wearing rugged Viking/Norse-inspired clothing and a Thor's hammer necklace. Do not put a helmet on him. Make the pose energetic and funny without becoming cartoonishly silly, with Clyde balancing on the barrel as though it is rolling beneath him. The barrel should look like an aged Vinland mead barrel with iron bands, but do not put text or a logo on it. Match the dark wood, aged iron, bronze and warm-firelight visual style of the existing Vinland Arcade graphics. Show the complete character and complete barrel with nothing cropped. Side profile facing RIGHT because this will eventually be used as a playable character moving across the screen. No scenery, no ground, no text, no additional characters. Transparent background. High resolution.
Then we'll probably want #16 eventually, which is the Easter egg's background/environment. That way Clyde and his barrel can actually move across the screen rather than being permanently baked into a static picture.
Filename: clyde_game_background.png
Create Graphic #16 for Vinland Arcade: the Clyde on His Mead Barrel game background. Create a wide cinematic side-scrolling Viking countryside at twilight, with distant mountains, pine forest, rolling hills, a fjord, and a distant Viking mead hall glowing warmly. Design it specifically as the background for a side-scrolling arcade mini-game. Keep the lower portion relatively simple because the ground and obstacles will be separate graphics. No people, animals, barrels, text, logos, roads, obstacles, or game interface elements. No horned helmets. Match the realistic cinematic style and warm bronze/firelight palette of the approved Clyde on His Mead Barrel character. Wide landscape composition, high resolution.
We can pan this slowly for a parallax effect.
Filename: clyde_ground.png
Create Graphic #17 for Vinland Arcade: the scrolling ground for Clyde on His Mead Barrel. Create a long horizontal strip of rugged Viking-era dirt trail with scattered grass, small stones, muddy patches and occasional wooden planks. It must be designed as a seamless horizontally repeating side-scrolling game ground texture, with the LEFT and RIGHT edges matching naturally when tiled. Side-view perspective. Do not include people, animals, barrels, buildings, obstacles, text, logos or large objects. Transparent background above the ground surface. Match the realistic cinematic style of Clyde on His Mead Barrel. High resolution.
Filename: pickup_mead_horn.png
This is our coin equivalent.
Create Graphic #18 for Vinland Arcade: a collectible mead drinking horn for the Clyde on His Mead Barrel mini-game. Create one small ornate Viking drinking horn with aged bronze fittings and a subtle warm golden glow so it immediately reads as a collectible game item. Side-view game asset, simple silhouette and recognizable at small size. No hand, person, text, logo, background or additional objects. Transparent PNG, high resolution.
Every horn collected can add points. 🍺
Filename: pickup_honey.png
Rare bonus item.
Create Graphic #19 for Vinland Arcade: a collectible honey jar for the Clyde on His Mead Barrel mini-game. Create one small old-fashioned glass jar filled with rich golden honey, capped simply and glowing subtly with warm amber light. Give it restrained Viking/Norse decorative details without any words, labels or logos. It must remain clearly recognizable as honey when displayed small. No background or additional objects. Transparent PNG, high resolution.
I'd make this worth substantially more than a horn.
Filename: obstacle_rock.png
Create Graphic #20 for Vinland Arcade: a rock obstacle for Clyde on His Mead Barrel. Create a single rugged dark stone protruding upward from the ground, large enough that Clyde must jump his rolling barrel over it. Side-view game asset with a clear simple silhouette. Weathered natural stone with subtle moss and dirt. No scenery, people, animals, text, logos or additional objects. Transparent PNG, high resolution.
Filename: obstacle_broken_barrel.png
Because jumping barrels while riding a barrel is exactly the correct level of nonsense.
Create Graphic #21 for Vinland Arcade: a broken barrel obstacle for Clyde on His Mead Barrel. Create a smashed old wooden mead barrel lying across the trail, with broken staves and aged iron hoops creating an obvious obstacle that must be jumped. Keep the silhouette readable at small size and avoid excessive loose debris. Side-view game asset. No text, logos, scenery, people or additional objects. Transparent PNG, high resolution.
Filename: obstacle_log.png
Create Graphic #22 for Vinland Arcade: a fallen log obstacle for Clyde on His Mead Barrel. Create one thick weathered fallen tree trunk lying horizontally across a trail, with a few short broken branches and patches of moss. Design it specifically as a side-view obstacle that a rolling barrel must jump over. Simple readable silhouette. No scenery, people, animals, text or additional objects. Transparent PNG, high resolution.
That gives the game three randomized obstacle types instead of endlessly hopping the same rock.
Filename: raven.png
This can be moving scenery or eventually an airborne hazard.
Create Graphic #23 for Vinland Arcade: a flying raven for Clyde on His Mead Barrel. Create one realistic dark raven in full side profile flying toward the RIGHT with wings extended in flight. It must remain recognizable at small game-sprite size. Match the realistic cinematic Viking atmosphere of the existing graphics. Show the entire bird with nothing cropped. No text, scenery or additional objects. Transparent PNG, high resolution.
Filename: mead_splash.png
For collecting a horn, bonus, collision, etc.
Create Graphic #24 for Vinland Arcade: a mead splash effect. Create an isolated dramatic splash of glowing amber-gold mead with droplets spreading outward, designed as a brief arcade-game visual effect. No glass, mug, horn, barrel, text, people or scenery. Transparent PNG, high resolution.
Filename: clyde_gameover_panel.png
The software adds the words and score.
Create Graphic #25 for Vinland Arcade: the Clyde on His Mead Barrel Game Over panel. Create a medium-sized dark aged-wood sign bordered with weathered iron and bronze, matching the established Vinland Arcade interface. Leave a large clean dark wooden center for software-generated GAME OVER, SCORE, HIGH SCORE and PLAY AGAIN text. Do not include any words, numbers, icons, logos or characters. Transparent exterior background. High resolution.
Filename: clyde_title.png
This one can contain text because it's the actual title artwork.
Create Graphic #26 for Vinland Arcade: the title logo for the hidden mini-game CLYDE ON HIS MEAD BARREL. Create the exact words “CLYDE ON HIS MEAD BARREL” as a dramatic but humorous vintage arcade title rendered in carved aged wood, weathered iron and warm bronze/gold, matching the Vinland Arcade Viking-mead-hall aesthetic. Keep it readable at small screen size. No character, barrel, scenery or additional wording. Transparent background, high resolution.
Filename: credits_background.png
Create Graphic #27 for Vinland Arcade: the Credits Background. Create a cinematic quiet Viking mead hall late at night after the feast has ended. The fires have burned low, candles remain glowing, wooden tables and benches sit empty, drinking horns and mugs are scattered naturally, and faint moonlight enters through the hall. Make it atmospheric, warm, slightly humorous in its “everyone finally went home” feeling, but still beautiful and realistic. Leave the entire CENTER of the composition dark and relatively uncluttered so software-generated credits can scroll vertically over it. No people, readable text, logos, game artwork or horned helmets. Wide landscape composition, high resolution.
Filename: credits_header.png
Create Graphic #28 for Vinland Arcade: the Credits Header. Create the exact words “VINLAND ARCADE” with a smaller line beneath reading “BUILT AT VINLAND MEADS” in the established carved aged-wood, weathered iron and bronze/gold Viking arcade style. This will appear at the beginning of a scrolling credits sequence. No shield, characters, scenery or additional text. Transparent background, high resolution.
Filename: credits_end.png
This is where I'd let the machine have some personality.
Create Graphic #29 for Vinland Arcade: the final credits graphic. Create the exact words “THANKS FOR PLAYING” with a smaller line beneath reading “NOW GO DRINK SOME MEAD.” Render it in the established Vinland Arcade carved wood, weathered iron and warm bronze/gold style. Make it playful but still polished and consistent with the rest of the interface. No characters, logos, scenery or additional wording. Transparent background, high resolution.
Then the actual credits are text generated by our program, so we can write whatever we want:
VINLAND ARCADE
Created by
Clyde Hays
Built at
Vinland Meads
Murchison, Texas
Powered by
Raspberry Pi
Custom Launcher
Vinland Arcade
Special Thanks
Sarah
Drew
Friends, Family & the Mead Hall Crew
And absolutely nobody who
puts horns on Viking helmets.
😂
I'd actually add one more hidden line at the very end, after a few seconds of apparently empty credits:
“Clyde should probably be working.”
#
Filename
Purpose
Tell me to create…
1
clyde_ride_1.png
Normal riding frame
“Create Clyde riding and balancing on top of a rolling wooden mead barrel. Clyde is bald with a full beard and no mustache, wearing Viking/Norse-style clothing and his Thor’s hammer necklace. No horn in his hand, no hawk, no weapons. Side view facing right. Transparent background. This is a 2D game sprite.”
2
clyde_ride_2.png
Second rolling frame
“Create the second animation frame matching clyde_ride_1. Clyde is still balancing on the rolling mead barrel, but slightly change his legs/body position and rotate the barrel so alternating the images creates movement. Same size, perspective and art style. Transparent background.”
3
clyde_jump.png
Jumping
“Create Clyde jumping while riding the mead barrel. Clyde and the barrel are airborne, with Clyde leaning back slightly to keep his balance. Match the riding sprites exactly. Side view facing right. No hawk or horn. Transparent background.”
4
clyde_land.png
Landing
“Create Clyde landing hard on the mead barrel after a jump, knees bent and body compressed from the impact. Match the other Clyde sprites exactly. Side view facing right. Transparent background.”
5
clyde_crash.png
Collision/game over
“Create Clyde wiping out after falling from his rolling mead barrel. Make it funny rather than gruesome, with Clyde and the barrel separated/tumbling. Match the existing game sprite style. Transparent background.”
6
barrel_dust_1.png
Movement effect
“Create a small puff of dust and dirt kicked up behind a rolling wooden barrel, for a 2D game animation. Transparent background, no barrel or character.”
7
barrel_dust_2.png
Second dust frame
“Create a second slightly larger/fading frame of the barrel dust effect, matching barrel_dust_1. Transparent background.”
8
hawk_fly_1.png
Flying companion
“Create Clyde’s hawk flying in side profile facing right, wings raised, matching the art style of the Clyde game. Hawk only. Transparent background.”
9
hawk_fly_2.png
Hawk animation
“Create the same hawk with wings lowered for the second flying-animation frame. Same size, orientation and style. Transparent background.”
Use your current clyde_game_background.png as the visual reference and ask:
Create a wide 2D side-scrolling game background matching this existing Clyde on His Mead Barrel artwork. Keep the same realistic cinematic Norse/Vinland landscape, warm sunset lighting, distant mountains, rustic settlement/mead-hall atmosphere, and overall color palette.
CRITICAL: This image must be seamlessly tileable HORIZONTALLY for an endless side-scrolling game. The LEFT EDGE and RIGHT EDGE must connect perfectly when identical copies are placed side-by-side. There must be no visible vertical seam, sudden lighting change, mismatched terrain, or objects cut off at either edge.
Keep distinctive buildings, mountains, trees, fires, and other major landmarks away from the extreme left and right edges so repetition is less obvious.
The player and foreground ground will be separate sprites, so do not include Clyde, barrels, characters, obstacles, pickups, hawks, ravens, text, logos, UI, or game elements.
Landscape orientation, 1024 × 600. This is an endlessly repeating horizontal game background, NOT a standalone landscape illustration.
Save the finished replacement as exactly:
clyde_game_background.png
Give it the existing clyde_ground.png as the reference and ask:
Create a long horizontal 2D game ground strip matching this existing Clyde on His Mead Barrel ground artwork. Rustic natural earth with short grass, dirt, small stones and subtle texture, matching the realistic cinematic style and warm lighting of the game.
CRITICAL: This ground must be seamlessly tileable HORIZONTALLY. The LEFT EDGE and RIGHT EDGE must connect perfectly when identical copies are placed side-by-side. There must be no visible seam, abrupt height change, mismatched grass, dirt, rocks, lighting, or cut-off objects at the edges.
Keep the top ground/silhouette height consistent at both edges so a rolling barrel appears to travel across continuous terrain.
Do not include Clyde, barrels, obstacles, pickups, animals, buildings, text, logos, or UI.
Transparent background above the ground. Wide horizontal game asset. Designed specifically for endlessly repeating side-scrolling terrain.
Save it as exactly:
clyde_ground.png
One important thing: after you make them, don't replace the current files yet. Show me the two new images first. I'll inspect the left/right edges. Then I can make another quick simulated scroll from the actual files and see whether we killed that seam before they go into our passed build.
VINLAND ARCADE – EASTER EGG & CREDITS NOTES
============================================
IMPORTANT:
The main Vinland Arcade launcher should be completed first.
DO NOT build the Easter egg until the primary arcade system is working and stable.
However, when writing the main launcher code, preserve the hooks needed for:
1. Hidden Easter egg activation
2. Credits screen
3. Easter egg high-score storage
--------------------------------------------------
HIDDEN EASTER EGG
--------------------------------------------------
NAME:
Clyde on His Mead Barrel
CONCEPT:
A hidden, simple endless-runner arcade game built directly into the custom
Vinland Arcade launcher.
This is NOT a ROM and does NOT use RetroArch.
Clyde rides/balances on a rolling wooden mead barrel while traveling through
a Viking/Vinland landscape.
The player jumps obstacles and collects items while the game gradually gets
faster.
The Easter egg should feel like a secret game somebody discovered inside
Vinland Arcade rather than part of the normal game library.
--------------------------------------------------
SECRET ACTIVATION
--------------------------------------------------
Tentative controller sequence from the Vinland Arcade main launcher:
UP
UP
DOWN
DOWN
LEFT
RIGHT
LEFT
RIGHT
B
A
START
Do not display this sequence anywhere in the normal interface.
The launcher code should listen for the sequence without interfering with
normal navigation.
--------------------------------------------------
GAMEPLAY
--------------------------------------------------
Basic endless-runner design.
Clyde and the barrel remain generally on the left side of the screen while
the environment moves from right to left.
Controls:
A = Jump
START = Pause
SELECT = Exit back to Vinland Arcade
Potential later controller options can be added if useful.
The game should begin fairly easy and gradually increase scrolling speed.
Collision with an obstacle ends the run.
--------------------------------------------------
SCORING
--------------------------------------------------
Score increases with distance/time survived.
Collectible Mead Horn = bonus points.
Rare Honey Jar = larger bonus.
Store a local HIGH SCORE.
No manual score entry.
--------------------------------------------------
OBSTACLES
--------------------------------------------------
Randomly use:
Rock
Broken Mead Barrel
Fallen Log
Spacing must always make the game physically possible to play.
Difficulty increases primarily through speed and obstacle frequency.
--------------------------------------------------
COLLECTIBLES
--------------------------------------------------
Mead Horn
Common collectible.
Honey Jar
Rare bonus collectible.
A mead splash visual effect can appear when certain items are collected.
--------------------------------------------------
ATMOSPHERE
--------------------------------------------------
Background:
Side-scrolling Viking countryside at twilight.
Possible scenery:
Fjord
Mountains
Pine forest
Rolling hills
Distant glowing mead hall
Ravens can occasionally fly through the scene.
Visual style must match Vinland Arcade:
dark aged wood
iron
bronze
warm firelight
cinematic Viking atmosphere
NO horned Viking helmets.
--------------------------------------------------
CLYDE CHARACTER
--------------------------------------------------
Graphic #15 has already been created and approved.
Filename:
clyde_barrel.png
Appearance reference:
Clyde Hays
Important visual characteristics:
Bald under/without headwear where appropriate
Full beard
NO mustache
Mjolnir / Thor's hammer necklace
Scottish/Viking-inspired clothing
Kilt
Rugged realistic appearance
Approved character graphic depicts Clyde balancing on a large rolling
wooden mead barrel, holding a mead mug and accompanied by a hawk.
Preserve this graphic. Do not regenerate it unless Clyde specifically asks.
--------------------------------------------------
EASTER EGG ASSETS STILL TO CREATE
--------------------------------------------------
#16 clyde_game_background.png
Side-scrolling Viking landscape.
#17 clyde_ground.png
Seamless scrolling ground.
#18 pickup_mead_horn.png
Collectible mead horn.
#19 pickup_honey.png
Rare honey bonus.
#20 obstacle_rock.png
Rock obstacle.
#21 obstacle_broken_barrel.png
Broken barrel obstacle.
#22 obstacle_log.png
Fallen log obstacle.
#23 raven.png
Flying raven.
#24 mead_splash.png
Transparent visual effect.
#25 clyde_gameover_panel.png
Blank Viking-style Game Over panel. Software adds text.
#26 clyde_title.png
Title graphic:
CLYDE ON HIS MEAD BARREL
The previously written prompts for Graphics #16–#26 should be reused when
we return to this project.
--------------------------------------------------
CREDITS SCREEN – DO NOT FORGET
--------------------------------------------------
VINLAND ARCADE MUST HAVE A CREDITS PAGE.
Build support for Credits when writing the main launcher code even if the
final graphics/text are added later.
Credits should be accessible from the Admin/About area rather than cluttering
the main game launcher.
Credits should scroll over a cinematic late-night empty Viking mead hall.
Credits graphics planned:
#27 credits_background.png
Quiet mead hall after the feast.
#28 credits_header.png
VINLAND ARCADE
BUILT AT VINLAND MEADS
#29 credits_end.png
THANKS FOR PLAYING
NOW GO DRINK SOME MEAD.
Most credits should be software-rendered text rather than baked into graphics
so they can be changed later.
Initial credits concept:
VINLAND ARCADE
Created by
Clyde Hays
Built at
Vinland Meads
Murchison, Texas
Powered by
Raspberry Pi
Custom Launcher
Vinland Arcade
Special Thanks
Sarah
Drew
Friends, Family & the Mead Hall Crew
And absolutely nobody who
puts horns on Viking helmets.
After the credits appear finished, wait briefly and display one final hidden
line:
"Clyde should probably be working."
--------------------------------------------------
CODING REQUIREMENT
--------------------------------------------------
When development of the main Vinland Arcade launcher begins:
DO NOT forget the Credits system.
Structure the software so Clyde on His Mead Barrel can later be added as an
internal mini-game without redesigning the launcher.
Leave support for:
- secret controller sequence detection
- Easter egg launch/return
- local Easter egg high score
- credits screen
- Credits entry in Admin/About
- separate Easter egg asset directory
Suggested future directory:
~/vinland-arcade/
easter-eggs/
clyde-barrel/
assets/
data/
game/
I want our own clean filenames rather than tying the launcher itself to RetroArch's sometimes-long filenames. That means the launcher database controls everything.
Create this file:
vinland-arcade/
└── data/
└── games.json
Put this in games.json:
{
"version": 1,
"games": [
{
"id": "smb",
"title": "Super Mario Bros.",
"system": "NES",
"year": 1985,
"players": "1-2",
"rom": "Super Mario Bros. (USA).nes",
"cover": "smb.png",
"core": "fceumm",
"favorite": false,
"rating": 0,
"play_count": 0
},
{
"id": "smb3",
"title": "Super Mario Bros. 3",
"system": "NES",
"year": 1990,
"players": "1-2",
"rom": "Super Mario Bros. 3 (USA).nes",
"cover": "smb3.png",
"core": "fceumm",
"favorite": false,
"rating": 0,
"play_count": 0
},
{
"id": "zelda",
"title": "The Legend of Zelda",
"system": "NES",
"year": 1987,
"players": "1",
"rom": "Legend of Zelda, The (USA).nes",
"cover": "zelda.png",
"core": "fceumm",
"favorite": false,
"rating": 0,
"play_count": 0
},
{
"id": "contra",
"title": "Contra",
"system": "NES",
"year": 1988,
"players": "1-2",
"rom": "Contra (USA).nes",
"cover": "contra.png",
"core": "fceumm",
"favorite": false,
"rating": 0,
"play_count": 0
},
{
"id": "punchout",
"title": "Mike Tyson's Punch-Out!!",
"system": "NES",
"year": 1987,
"players": "1",
"rom": "Mike Tyson's Punch-Out!! (USA).nes",
"cover": "punchout.png",
"core": "fceumm",
"favorite": false,
"rating": 0,
"play_count": 0
},
{
"id": "tecmo",
"title": "Tecmo Super Bowl",
"system": "NES",
"year": 1991,
"players": "1-2",
"rom": "Tecmo Super Bowl (USA).nes",
"cover": "tecmo-super-bowl.png",
"core": "fceumm",
"favorite": false,
"rating": 0,
"play_count": 0
},
{
"id": "excitebike",
"title": "Excitebike",
"system": "NES",
"year": 1985,
"players": "1",
"rom": "Excitebike (USA).nes",
"cover": "excitebike.png",
"core": "fceumm",
"favorite": false,
"rating": 0,
"play_count": 0
},
{
"id": "ducktales",
"title": "DuckTales",
"system": "NES",
"year": 1989,
"players": "1",
"rom": "DuckTales (USA).nes",
"cover": "ducktales.png",
"core": "fceumm",
"favorite": false,
"rating": 0,
"play_count": 0
},
{
"id": "megaman2",
"title": "Mega Man 2",
"system": "NES",
"year": 1989,
"players": "1",
"rom": "Mega Man 2 (USA).nes",
"cover": "mega-man-2.png",
"core": "fceumm",
"favorite": false,
"rating": 0,
"play_count": 0
},
{
"id": "drmario",
"title": "Dr. Mario",
"system": "NES",
"year": 1990,
"players": "1-2",
"rom": "Dr. Mario (USA).nes",
"cover": "dr-mario.png",
"core": "fceumm",
"favorite": false,
"rating": 0,
"play_count": 0
},
{
"id": "smw",
"title": "Super Mario World",
"system": "SNES",
"year": 1991,
"players": "1-2",
"rom": "Super Mario World (USA).sfc",
"cover": "super-mario-world.png",
"core": "snes9x2010",
"favorite": false,
"rating": 0,
"play_count": 0
},
{
"id": "mariokart",
"title": "Super Mario Kart",
"system": "SNES",
"year": 1992,
"players": "1-2",
"rom": "Super Mario Kart (USA).sfc",
"cover": "super-mario-kart.png",
"core": "snes9x2010",
"favorite": false,
"rating": 0,
"play_count": 0
},
{
"id": "zeldalttp",
"title": "The Legend of Zelda: A Link to the Past",
"system": "SNES",
"year": 1992,
"players": "1",
"rom": "Legend of Zelda, The - A Link to the Past (USA).sfc",
"cover": "zelda-link-to-past.png",
"core": "snes9x2010",
"favorite": false,
"rating": 0,
"play_count": 0
},
{
"id": "dkc",
"title": "Donkey Kong Country",
"system": "SNES",
"year": 1994,
"players": "1-2",
"rom": "Donkey Kong Country (USA).sfc",
"cover": "donkey-kong-country.png",
"core": "snes9x2010",
"favorite": false,
"rating": 0,
"play_count": 0
},
{
"id": "sf2turbo",
"title": "Street Fighter II Turbo",
"system": "SNES",
"year": 1993,
"players": "1-2",
"rom": "Street Fighter II Turbo (USA).sfc",
"cover": "street-fighter-ii-turbo.png",
"core": "snes9x2010",
"favorite": false,
"rating": 0,
"play_count": 0
},
{
"id": "mk2",
"title": "Mortal Kombat II",
"system": "SNES",
"year": 1994,
"players": "1-2",
"rom": "Mortal Kombat II (USA).sfc",
"cover": "mortal-kombat-ii.png",
"core": "snes9x2010",
"favorite": false,
"rating": 0,
"play_count": 0
},
{
"id": "nbajam",
"title": "NBA Jam Tournament Edition",
"system": "SNES",
"year": 1995,
"players": "1-2",
"rom": "NBA Jam - Tournament Edition (USA).sfc",
"cover": "nba-jam-te.png",
"core": "snes9x2010",
"favorite": false,
"rating": 0,
"play_count": 0
},
{
"id": "fzero",
"title": "F-Zero",
"system": "SNES",
"year": 1991,
"players": "1",
"rom": "F-Zero (USA).sfc",
"cover": "f-zero.png",
"core": "snes9x2010",
"favorite": false,
"rating": 0,
"play_count": 0
},
{
"id": "supermetroid",
"title": "Super Metroid",
"system": "SNES",
"year": 1994,
"players": "1",
"rom": "Super Metroid (USA).sfc",
"cover": "super-metroid.png",
"core": "snes9x2010",
"favorite": false,
"rating": 0,
"play_count": 0
},
{
"id": "tmnt4",
"title": "Teenage Mutant Ninja Turtles IV: Turtles in Time",
"system": "SNES",
"year": 1992,
"players": "1-2",
"rom": "Teenage Mutant Ninja Turtles IV - Turtles in Time (USA).sfc",
"cover": "tmnt-iv.png",
"core": "snes9x2010",
"favorite": false,
"rating": 0,
"play_count": 0
}
]
}
Those ROM filenames are expected names, not something I'm declaring your actual files are named. Tomorrow we'll run a little matching script against the game files you're legally entitled to use and automatically reconcile the manifest with their real filenames.
The cover names, however, are ours. That gives our launcher nice predictable paths such as:
artwork/nes/smb3.png
artwork/nes/zelda.png
artwork/snes/super-mario-world.png
artwork/snes/super-metroid.png
Libretro's source files can retain their ugly database names. Our download/prep script will fetch them and rename them into our clean Vinland names. RetroArch's own documentation confirms that its standard thumbnails are PNGs and normally use title-matching names.
Also, favorites, rating and play count will eventually move out of the static manifest into user-state data. I've included them here initially so the launcher has sane defaults, but I don't want every play session rewriting our master game catalog.
We can write this today without the Pi. I want to use Python + Pygame for the launcher. It gives us fullscreen graphics, controller input, touchscreen/mouse input, animation, image scaling, and later the Clyde mini-game without dragging a browser into the stack. Pygame supports Linux Wayland/X11 display drivers, which fits Raspberry Pi OS Desktop.
One adjustment from our older plan: on current Raspberry Pi OS, we should favor apt for packaged Python dependencies rather than dumping packages into system Python with pip. Raspberry Pi explicitly recommends that approach on Bookworm and later.
We're going to build toward this:
vinland-arcade/
│
├── launcher/
│ ├── main.py
│ ├── ui.py
│ ├── games.py
│ ├── input.py
│ ├── retroarch.py
│ ├── credits.py
│ └── admin.py
│
├── assets/
│ ├── ui/
│ ├── backgrounds/
│ ├── credits/
│ └── fonts/
│
├── artwork/
│ ├── nes/
│ └── snes/
│
├── roms/
│ ├── nes/
│ └── snes/
│
├── data/
│ ├── games.json
│ └── user_state.json
│
├── easter-eggs/
│ └── clyde-barrel/
│ ├── assets/
│ ├── data/
│ └── game/
│
├── config/
├── logs/
└── scripts/
That separation is intentional. Game information stays in games.json; changing information stays in user_state.json.
For example:
{
"smb3": {
"favorite": true,
"rating": 5,
"play_count": 17
}
}
We're not going to rewrite the master catalog every time somebody plays Mario.
Since we're not on the Pi, we're going to make the first version deliberately tolerant of missing artwork. That way it can run before we've downloaded the covers.
Create:
vinland-arcade/launcher/main.py
Put this entire file in it:
#!/usr/bin/env python3
import json
import sys
from pathlib import Path
import pygame
# ---------------------------------------------------------
# VINLAND ARCADE
# Main Launcher
# ---------------------------------------------------------
BASE_DIR = Path(__file__).resolve().parent.parent
DATA_DIR = BASE_DIR / "data"
ARTWORK_DIR = BASE_DIR / "artwork"
ASSET_DIR = BASE_DIR / "assets"
GAME_DATABASE = DATA_DIR / "games.json"
DESIGN_WIDTH = 1280
DESIGN_HEIGHT = 720
FPS = 60
class VinlandArcade:
def __init__(self):
pygame.init()
pygame.joystick.init()
self.screen = pygame.display.set_mode(
(DESIGN_WIDTH, DESIGN_HEIGHT),
pygame.RESIZABLE
)
pygame.display.set_caption("Vinland Arcade")
self.clock = pygame.time.Clock()
self.running = True
self.selected_game = 0
self.games = self.load_games()
self.font_title = pygame.font.Font(None, 64)
self.font_game = pygame.font.Font(None, 52)
self.font_info = pygame.font.Font(None, 30)
self.font_small = pygame.font.Font(None, 24)
self.joysticks = []
self.detect_controllers()
# -----------------------------------------------------
# DATA
# -----------------------------------------------------
def load_games(self):
if not GAME_DATABASE.exists():
print(f"ERROR: Game database not found:")
print(GAME_DATABASE)
sys.exit(1)
with GAME_DATABASE.open("r", encoding="utf-8") as file:
data = json.load(file)
games = data.get("games", [])
if not games:
print("ERROR: No games found in games.json")
sys.exit(1)
print(f"Loaded {len(games)} games.")
return games
# -----------------------------------------------------
# CONTROLLERS
# -----------------------------------------------------
def detect_controllers(self):
self.joysticks.clear()
for index in range(pygame.joystick.get_count()):
joystick = pygame.joystick.Joystick(index)
joystick.init()
self.joysticks.append(joystick)
print(
f"Controller {index + 1}: "
f"{joystick.get_name()}"
)
# -----------------------------------------------------
# NAVIGATION
# -----------------------------------------------------
def previous_game(self):
self.selected_game -= 1
if self.selected_game < 0:
self.selected_game = len(self.games) - 1
def next_game(self):
self.selected_game += 1
if self.selected_game >= len(self.games):
self.selected_game = 0
# -----------------------------------------------------
# INPUT
# -----------------------------------------------------
def handle_events(self):
for event in pygame.event.get():
if event.type == pygame.QUIT:
self.running = False
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
self.running = False
elif event.key == pygame.K_LEFT:
self.previous_game()
elif event.key == pygame.K_RIGHT:
self.next_game()
elif event.key in (
pygame.K_RETURN,
pygame.K_SPACE
):
self.play_selected_game()
elif event.type == pygame.JOYBUTTONDOWN:
# Temporary mapping.
# Real controller mappings will be established
# on the Raspberry Pi tomorrow.
if event.button == 0:
self.play_selected_game()
elif event.type == pygame.JOYHATMOTION:
x, y = event.value
if x < 0:
self.previous_game()
elif x > 0:
self.next_game()
# -----------------------------------------------------
# GAME LAUNCHING
# -----------------------------------------------------
def play_selected_game(self):
game = self.games[self.selected_game]
print()
print("--------------------------------")
print("VINLAND ARCADE")
print("--------------------------------")
print(f"Launching: {game['title']}")
print(f"System: {game['system']}")
print(f"Core: {game['core']}")
print(f"ROM: {game['rom']}")
print("--------------------------------")
print()
# RetroArch launching gets connected tomorrow.
# For now this proves the UI selection pipeline works.
# -----------------------------------------------------
# DRAWING
# -----------------------------------------------------
def draw_background(self):
self.screen.fill((18, 12, 8))
def draw_header(self):
title = self.font_title.render(
"VINLAND ARCADE",
True,
(205, 166, 93)
)
rect = title.get_rect(
center=(DESIGN_WIDTH // 2, 75)
)
self.screen.blit(title, rect)
def draw_game(self):
game = self.games[self.selected_game]
# Placeholder cover area
cover_rect = pygame.Rect(
470,
145,
340,
390
)
pygame.draw.rect(
self.screen,
(45, 31, 20),
cover_rect
)
pygame.draw.rect(
self.screen,
(165, 126, 70),
cover_rect,
4
)
placeholder = self.font_info.render(
"GAME COVER",
True,
(150, 135, 110)
)
placeholder_rect = placeholder.get_rect(
center=cover_rect.center
)
self.screen.blit(
placeholder,
placeholder_rect
)
# Game title
title = self.font_game.render(
game["title"],
True,
(225, 202, 151)
)
title_rect = title.get_rect(
center=(DESIGN_WIDTH // 2, 585)
)
self.screen.blit(
title,
title_rect
)
# Game information
info_text = (
f"{game['system']} • "
f"{game['year']} • "
f"{game['players']} PLAYER"
)
info = self.font_info.render(
info_text,
True,
(190, 180, 160)
)
info_rect = info.get_rect(
center=(DESIGN_WIDTH // 2, 630)
)
self.screen.blit(
info,
info_rect
)
def draw_navigation(self):
left = self.font_title.render(
"<",
True,
(180, 145, 80)
)
right = self.font_title.render(
">",
True,
(180, 145, 80)
)
self.screen.blit(
left,
(100, DESIGN_HEIGHT // 2)
)
self.screen.blit(
right,
(1140, DESIGN_HEIGHT // 2)
)
def draw_footer(self):
text = (
"LEFT / RIGHT: SELECT GAME "
"ENTER: PLAY "
"ESC: EXIT"
)
footer = self.font_small.render(
text,
True,
(120, 110, 95)
)
footer_rect = footer.get_rect(
center=(DESIGN_WIDTH // 2, 690)
)
self.screen.blit(
footer,
footer_rect
)
def draw(self):
self.draw_background()
self.draw_header()
self.draw_game()
self.draw_navigation()
self.draw_footer()
pygame.display.flip()
# -----------------------------------------------------
# MAIN LOOP
# -----------------------------------------------------
def run(self):
while self.running:
self.handle_events()
self.draw()
self.clock.tick(FPS)
pygame.quit()
# ---------------------------------------------------------
# START VINLAND ARCADE
# ---------------------------------------------------------
if __name__ == "__main__":
arcade = VinlandArcade()
arcade.run()
This isn't intended to be pretty yet. It's the chassis underneath all that gorgeous Viking metalwork we just made.
Already built into it are:
60 FPS rendering
games.json loading
20-game carousel navigation
wraparound from game 20 → game 1
keyboard testing
basic controller detection
D-pad/hat navigation
Play command pipeline
NES/SNES metadata
placeholder covers
clean place to connect RetroArch tomorrow
And notice what I didn't hard-code into it yet: controller button numbers beyond a temporary A-button assumption, RetroArch paths, screen resolution, ROM paths or Pi-specific display behavior. Those are things we'll discover from the actual machine rather than guess today.
We're designing internally at 1280×720, but we're not going to assume that's the physical touchscreen resolution. Tomorrow we'll query the actual display and scale the interface accordingly.
That means the same launcher can eventually render on the 5-inch test screen and 7-inch final screen without maintaining two versions.
And when we deploy on Raspberry Pi OS, we'll use the supported package-management route for Pygame rather than fighting PEP 668.