Improving The Atari VCS (VCS Steam Machine v1.0)

Let me just start this number by admitting that, no, the Atari VCS isn’t a great value proposition on paper. It’s under-powered and the software support is lacking (at best). For $300, it’s not worth the money compared to a dedicated console or even a used enterprise small form-factor PC. That being said, the VCS is a fantastic little tinkering and casual gaming platform if you can find it on sale!

I grabbed an “All-In” bundle and an extra classic controller (I already had a modern controller on hand) for under $200US after Thanksgiving with the intent to see what it was all about. There’s a lot of hate surrounding this little console, and I feel like much of it is undeserved–especially comparing it to something like the Steam Deck. While the Steam Deck is slightly more powerful on paper (and portable), the VCS is still a gorgeous piece of hardware that is not only upgradeable, but also significantly less expensive even factoring in those upgrades. The VCS does have its problems, though: AtariOS looks pretty good, but it’s hobbled by virtually nonexistent software support. Thankfully, Atari had the foresight to allow alternative operating systems to be installed (remember when you could officially run Linux on a PlayStation 2?). It’s in this spirit that I’m documenting my journey to build a custom TV-based gaming console. The hardware is mostly settled: I have a VCS with 2 modern controllers and 2 classic controllers. I’ve already installed 32GB of RAM and once I’m finished, I’ll install an SSD for internal storage (there are myriad videos showing the process for both, so I won’t detail them here). For now, development will take place on an external HDD.

Extracting the bits I want to keep

AtariOS is pretty slick, but it does leave a bit to be desired in the software department. Since this is a Debian-based system, I want to be able to add my own games (or, at least, launchers such as Steam, Epic, or–ick–Amazon, but the only way I’ve found to do so is through Atari’s homebrew portal. Unfortunately, my research tells me that homebrew is only available to developers who have submitted work to Atari for inclusion in their store. Even still, I prefer to have all my games under one unified interface instead of trying to remember which ones I bought through Steam or GoG and which ones I got free from Epic and Amazon, so the best option is to try and use it as the basis for a frontend theme under an alternative OS.

First off, I absolutely love the boot animation featuring Asteroids, so I need to find it hidden in the firmware. It’s a pretty bog-standard Debian partition, so I can fire up a Kubuntu Live USB and dig around the file system. Except that I can’t because Secure Boot is active on the BIOS.

Disabling Secure Boot in BIOS

Spamming the Escape key during boot will drop you into the BIOS menu, but evidently I updated the BIOS on my fresh boot of the VCS, so I can’t access any of the settings without the right password. This isn’t too big a problem to solve, but finding the firmware flasher is the difficult part as Atari saw fit to remove it from their servers. Fortunately, someone has posted the image to the Internet Archive, so it’s still available until it’s not. Burn it to a USB stick and boot it up to revert the BIOS to the previous version. From here, use the BIOS password Atar!C3l3br8te$50Ye4r$ to disable secure boot (and change the BIOS password while you’re at it).

Locating the boot animation

Now that I’ve got a Kubuntu Live instance running, I can fire up Dolphin and dig around the embedded file system to see if I can locate any goodies. The Asteroids boot animation is located at rootfs/usr/local/dashboard/Dashboard_Data/StreamingAssets/BootSplashHD.webm, so I can copy that for use later.

The Atari VCS Vault

The other piece of embedded software that I want to keep is the VCS Vault, a rebranded version of the Atari Vault software package from 2016. There’s no DRM on it, so it can easily be copied from storage/games/vault. There are also some artwork assets in rootfs/usr/local/dashboard/Dashboard_Data/StreamingAssets/LocalPortalsData that might prove useful later as well. There are a few other bits and bobs, such as the embedded Stella, MAME, and DOSBox emulators that can be made visible on the main menu, but nothing unique that I really need before building the new system.

SteamDeck as inspiration

Atari offers an optional USB with a custom Debian distro for their “PC Mode”. It’s pretty, but I’m really only interested in the wallpaper. For my custom VCSOS, I’m going to take the Steam Deck as inspiration and attempt to boot directly into a games launcher with a desktop mode accessible underneath. The Steam Deck uses a custom distribution of Arch Linux which is a bit of a departure for me, so I’ll stick with an Ubuntu-based installation that I’m more comfortable with. For the desktop environment, I’ll use KDE Plasma like the Steam Deck (because it looks good and works well). I could use HoloISO, but I’m not trying to build an exact Steam Deck clone and I’m not sure what kind of jiggery-pokery the developer employed to “reverse engineer” SteamOS3, so I’ll stick with the ground-up approach.

Backing up AtariOS

Redo Rescue is a Debian-based live USB that can be used to image hard drives for backup and restore purposes. Boot the live USB and follow the directions to image the embedded flash memory to a separate USB drive. This image can be restored to a USB flash drive later through the Redo Rescue interface if you need to access AtariOS.

Install Kubuntu

The one thing I don’t like about Kubuntu is the fact that it installs with quite a lot of bloatware, but the current version of Ubuntu Server Edition has a problem with WiFi radio drivers otherwise I would’ve just installed KDE Plasma on top of it and have a beautiful minimal OS installation. Instead, I needed to take a few minutes to uninstall all the unnecessary packages (games, LibreOffice, etc.).

Install kio-admin

Now, call me spoiled or lazy, but I prefer to do my file management through the GUI instead of typing lines upon lines of commands. As such, I’ll need to install the kio-admin package which gives me a context menu option to open folders as admin. It’s just one of those little things that makes life a little easier when messing around with protected system files. To install, you’ll need to add the backports repo to apt:
sudo add-apt-repository ppa:kubuntu-ppa/backports
sudo apt-get update
sudo apt install kio-admin

Install AMD GPU Drivers

sudo apt update
sudo apt dist-upgrade
dpkg --add-architecture i386
sudo apt update
sudo apt install mesa-vulkan-drivers mesa-vulkan-drivers:i386

Quieting the boot log

Part of the Linux aesthetic is the firehose of system log entries that post during boot, but I’m trying to get this system as close to a “console” as possible (despite the longish cold boot time) so I need to change a couple of kernel options in the GRUB bootloader. To do this, open /etc/default/grub in a text editor and change the following values:
GRUB_CMDLINE_LINUX_DEFAULT="quiet splash loglevel=0"
GRUB_CMDLINE_LINUX="loglevel=0"
Once the changes are saved, invoke sudo update-grub at the command prompt and reboot. The Atari logo and Kubuntu splash animation should show with no other text displayed.

Install Steam

sudo apt install steam steam-devices x11-utils

Customize Kubuntu

At this point, we start making Kubuntu look more like a polished product. The easiest way is to customize the Plasma desktop environment to make everything a little more polished. Since most of my games are on Steam (and because it already has Proton integrated), I’ll use that as the main UI. I attempted to boot directly into Steam, but it proved more trouble than it was worth, so we’ll stick with launching Big Picture Mode from the Plasma desktop. Other customizations that I recommend:

  • Disable lock screen
    system settings>workspace behavior>screen locking
  • Paste the wallpapers from AtariOS in /usr/share/wallpapers and enable in settings
  • Disable blink LED on sleep
    BIOS>Setup Utility>AMD PBS>BLINK LED>Disable
  • Enable NumLock on boot
    BIOS>Setup Utility>Advanced>Boot Configuration
  • Copy VCS Vault to storage and add to Steam (Make LauncherScript executable and change ownership)
  • Install SGDBoop
  • Configure fstab to mount drives automatically
  • Disable Plasma Splash Screen
  • Automatically log in

Install Custom Plymouth Theme

While I’m not opposed to the Atari “Fuji” logo hanging out during the boot sequence, I take some umbrage at the Kubuntu logo flashing below it. It’s nothing extremely bothersome, but I would prefer to minimize the OS branding to keep the system looking as much like a “console” as possible. As such, I put together a simple boot animation using the Atari VCS logo rotating through its color scheme that shows for a few seconds while everything loads from the internal memory. To get the theme installed, copy it to the /usr/share/plymouth/themes/ folder, then invoke the following command to actually install it:
sudo update-alternatives --install /usr/share/plymouth/themes/default.plymouth default.plymouth /usr/share/plymouth/themes/mytheme/mytheme.plymouth 80
That last number is a way to indicate to Kubuntu what priority the particular theme should take if there are multiple themes installed–just in case something goes wrong. It’s essentially arbitrary since we’re going to manually select it:
sudo update-alternatives --config default.plymouth
Optionally, you can delete any other themes that are installed if you’re not going to use them using the following command:
sudo update-alternatives --remove default.plymouth /path/folder/theme/to/uninstall/file-theme.plymouth
Finally, you just have to update the initial RAM file system to activate the new theme on boot:
sudo update-initramfs -u

Wake from Bluetooth

One last thing we need to do is re-enable the wake with controller function that AtariOS had. Unfortunately, this functionality still isn’t baked into Ubuntu yet. To do this, we need to drop a couple of scripts in /usr/local/sbin/ to handle selecting the device for wakeup (the Bluetooth radio) and the wakeup function itself. Full credit for this goes to Nicholas Bernaerts whose defunct website  outlined the process in detail. The first thing is to make sure that “Wake On USB” is enabled in BIOS (unless you changed this, it should be). Once that is confirmed, you’ll also need to verify that the Zenity package (sudo apt install zenity) is installed. At this point, we can put our scripts together:
sudo nano /usr/local/sbin/enable-wakeup
sudo nano /usr/local/sbin/select-resume-devices
sudo chmod +x /usr/local/sbin/enable-wakeup
sudo chmod +x /usr/local/sbin/select-resume-devices
Copy the code for each of the scripts to the correct file using either Nano or (my preference) Kate, then you can launch the select-resume-devices script (sudo /usr/local/sbin/select-resume-devices). This will bring up a window where you can select which USB device(s) you want to enable wake with. Once finished, you can verify the process by checking the 90-hid-wakeup-enable.rules file created in /etc/udev/rules.d/. Finally, reboot the system for everything to take effect.

enable-wakeup

#!/bin/bash
#
# Script to enable a USB devices to be used to resume computer from sleep
#
# Depends on udevadm package
# 09/05/2012 - V1.0 by Nicolas Bernaerts

# if device has been removed, exit
[ "$ACTION" = "remove" ] && exit 0

# set PATH as it is not set for udev scripts
PATH="/usr/sbin:/usr/bin:/sbin:/bin"

# set device SYSFS path
DEVICE_SYSFS="/sys$1"
CURRENT_SYSFS=$DEVICE_SYSFS

# get device product and vendor name from parent SYSFS
DEVICE_VENDOR=`udevadm info --query=all -p "$CURRENT_SYSFS/../" | grep "ID_VENDOR_ID=" | cut -d "=" -f 2`
DEVICE_PRODUCT=`udevadm info --query=all -p "$CURRENT_SYSFS/../" | grep "ID_MODEL_ID=" | cut -d "=" -f 2`
DEVICE_LABEL=`lsusb | grep "${DEVICE_VENDOR}:${DEVICE_PRODUCT}" | sed 's/^.*[0-9a-f]\:[0-9a-f]* \(.*\)$/\1/g'`

# loop thru the SYSFS path, up to PCI bus
CARRY_ON=1
while [ $CARRY_ON -eq 1 ]
do
  # get the first three letters of current SYSFS folder
  FIRST_LETTERS=`basename $CURRENT_SYSFS | sed 's/^\(...\).*$/\1/g'`

  # if current SYSFS is PCI bus, stop the loop
  if [ "$FIRST_LETTERS" = "pci" ] || [ "$FIRST_LETTERS" = "/" ] ; then
    CARRY_ON=0

  # else,
  else
    # if possible, enable wakeup for current SYSFS
    WAKEUP_FILE="${CURRENT_SYSFS}/power/wakeup"
    if [ -f $WAKEUP_FILE ]; then
      echo "enabled" > $WAKEUP_FILE
    fi

    # go to father directory of current SYSFS
    CURRENT_SYSFS=`dirname $CURRENT_SYSFS`
  fi
done

# log the action
LOG_HEADER="USB device ${DEVICE_VENDOR}:${DEVICE_PRODUCT}"
logger "${LOG_HEADER} - Description : ${DEVICE_LABEL}"
logger "${LOG_HEADER} - SysFS path  : ${DEVICE_SYSFS}"
logger "${LOG_HEADER} - Device is enabled to handle suspend/resume"

select-resume-devices

#!/bin/bash
#
# Script to create resume udev rules for USB devices
#
# Depends on zenity
# 09/05/2012 - V1.0 by Nicolas Bernaerts

# udev file to generate
UDEV_FILE="/etc/udev/rules.d/90-hid-wakeup-enable.rules"

# set separator as CR
IFS=$'\n'

# list all USB devices, excluding root & hubs
LIST_DEVICE=(`lsusb | grep -v "0000:0000" | grep -iv "hub" | sed 's/^.*[0-9a-f]\:[0-9a-f]* \(.*\)$/\1/g'`)

# loop thru the devices array to generate zenity parameter
for DEVICE in "${LIST_DEVICE[@]}"
do
  # if needed, remove [xxx] from device name as it gives trouble with grep
  DEVICE=`echo "$DEVICE" | sed 's/\[.*\]//g'`

  # add it to the parameters list
  ARR_PARAMETER=( FALSE ${DEVICE} ${ARR_PARAMETER[@]} )
done

# display the dialog box to choose devices
TITLE="Wakeup - Enable USB devices"
TEXT="Please, select USB devices you want to use to resume your computer"
CHOICE=`zenity --list --width=600 --height=250 --text=$TEXT --title=$TITLE --checklist --column "Select" --column "Device name" "${ARR_PARAMETER[@]}"`

# slit the device choice into an array
IFS="|" read -a ARR_CHOICE <<< "$CHOICE"

# if at least one device has been selected, initialise udev rules file
[ ${#ARR_CHOICE[@]} -gt 0 ] && echo "# udev rule for USB wake-up of selected devices" > $UDEV_FILE
[ ${#ARR_CHOICE[@]} -gt 0 ] && echo "#" >> $UDEV_FILE

# loop thru the selected devices to create udev rules
for DEVICE_NAME in "${ARR_CHOICE[@]}"
do
  # get current device data
  DEVICE_DATA=`lsusb | grep "${DEVICE_NAME}" | sed 's/^.*ID \([0-9a-f]*\):\([0-9a-f]*\).*$/\1|\2/g'`
  DEVICE_VENDOR=`echo $DEVICE_DATA | cut -d"|" -f1`
  DEVICE_PRODUCT=`echo $DEVICE_DATA | cut -d"|" -f2`

  # create udev rule for current device
  DEVICE_RULE="SUBSYSTEM==\"usb\", ATTRS{idVendor}==\"$DEVICE_VENDOR\", ATTRS{idProduct}==\"$DEVICE_PRODUCT\" RUN+=\"/usr/local/sbin/enable-wakeup \$env{DEVPATH}\" "

  # add udev rule for current device
  echo "# ${DEVICE_NAME}" >> $UDEV_FILE
  echo ${DEVICE_RULE} >> $UDEV_FILE
done

# if at least one device has been selected, display notification
TITLE="USB resume enabled"
TEXT="Your USB devices are resume enabled.\nTo finalize configuration you have to do one of these actions :\n- replug USB devices\n- reboot the computer"
[ ${#ARR_CHOICE[@]} -gt 0 ] && notify-send --icon=media-eject $TITLE $TEXT

Customize Steam

At this point, the VCS is ready to go. You can fire up Steam from the desktop and go to town, but there are 2 more tweaks that I want to make to Steam for the full console effect. The first is simply getting Steam to run at boot. You can do this easily by adding Steam to the Autostart list in Plasma’s system settings, but you’ll want to make sure to add the -bigpicture flag to the command so that it opens in Big Picture mode. The last thing is to add the Asteroids boot animation that we scavenged from AtariOS to Steam’s startup. In the Steam installation’s configuration folder (~/.steam/steam/config/), create a folder called uioverrides, then inside it create a folder called movies. Copy the video file to this location. In Steam’s configuration menu, you should see a dialog where you can select the startup animation as well as select whether you want to play the video when you wake from sleep or not. Now, you’re ready to go–reboot, install some games, and get to playing!

Have you played Atari today?

How To Install Windows 95 in PCem

If you’re at all familiar with the content of this site, you know that I’m a sucker for retro technology, especially media. I’ve spent years collecting vintage computers, software, and other multimedia, but with children on the way, I’m finding myself in need of paring down my extensive physical collection in favor of a smaller, better-curated one. Fortunately, emulation technology has improved drastically since the days of NESticle and purpose-built emulation boxes like the NES and SNES Classic can offer much of the visceral experience of these older platforms without the limitations of the original hardware. The nice thing about a PC is that the form factor hasn’t changed all that much, so emulating an older machine on top of a new one hasn’t eroded the experience too much. Sure, you’re probably missing the feeling of throwing a chunky power switch on a beige desktop box, but the application of the right keyboard and mouse can supplement the tactile experience enough to fool me at least for a while.

Enter PCem, hands-down the absolute best way to emulate older PC hardware on modern machines–right down to the BIOS beeps. It’s not without its quirks and remembering how to do things from the time when PCs still came with manuals can be a little bit of a challenge, but it’s the best way to experience Windows 95/98 applications in all their 16-bit (and 32-bit) glory!

Supplies needed:

  • PCem, of course. Version 17 is current as of this writing.
  • The right BIOS file for the motherboard you’re going to emulate. There’s several archvies of all the compatible BIOSes floating around, I usually go for one hosted by Archive.org.
  • A copy of Windows 95. OSR 2.5 is the most compatible with PCem and includes all the updates to that point, so you’ll have the best experience with it. You’ll also need a valid CD key.
  • Windows 95 boot disk.
  • Windows 9x Voodoo drivers (for that sweet, sweet graphics acceleration).
  • S3 Video drivers.
  • CD image management software. I will be using PowerISO.

Install and Configure PCem:

PCem is a portable application, so it doesn’t actually need to be “installed” anywhere. Just extract the archive to a convenient location on your hard drive. Extract the BIOS archive and place the contents inside PCem’s “Roms” folder. Now, run PCem.exe to open the Configuration Manager. Click the “New” button to set up a new emulator, give it a name, then you’ll have the main configuration window.

For the machine, select “[Socket 7] Shuttle HOT-557”. This will give you options for various Pentium processors. My Core i7 lappy can reliably handle a P120, so I’ll set that as the CPU. 128MB of RAM will be plenty for most Win95-era games. Make sure that “Synchronize time to host clock” is checked, then move on to the video tab.

I’m going to set my video adapter to “Phoenix S3 Trio32” with “Fast VLB/PCI” speed. I’ll also enable Voodoo Graphics. In the Voodoo settings, bump the framebuffer and texture memory up to 4MB. Enable bilinear filtering and Recompiler, and 2 render threads.

In the audio tab, set whichever Sound Blaster you want (why no the AWE32?), and now we need to set up the drives.

Set your HDD as a standard IDE, FDD1 as a 3.5″ floppy drive (1.44MB), FDD2 as none, and CD model as PCemCD (24X speed because why not?). Now we need to create the HDD image. For Drive 0, create a new hard drive image by clicking the “New” button. I prefer a dynamic-size VHD because it will grow as you add more to it. Set it for it 63 sectors, 16 heads, and 16383 cylinders which should give you roughly 8GB.

Mouse, joystick, and network options are at your prerogative. Now, let’s fire up the emulator!

Once the BIOS POST screen comes up, hit Del to enter the standard CMOS setup. Set the primary master to “Auto” and the other drives to “None”. In the emulator Disc menu, change Drive A: to your Windows 95 boot disk *.img file. Now you can save the BIOS settings and reboot the emulator.

Install Windows 95:

Once the emulator reboots, you’ll see the following screen. Type 1 and press Enter to start the computer with CD-ROM support.

After a few moments, you’ll get a warning that the primary hard drive has not been formatted and Windows will dump you at the A:\> prompt. Run fdisk to format the hard drive, and make sure to enable large disk support. In the FDISK application, type 1 and Enter to create a DOS partition or logical DOS drive. Make the maximum space available and then make the current partition the active partition. Once FDISK is finished, you’ll need to restart the emulator.

Once you’re back to the A:\> prompt, invoke the command format c: to format the new hard drive partition. Once formatting is finished, we’re ready to actually install Windows 95. From the PCem Disc menu, mount the Windows 95 installation disc (or point it to your physical CD-ROM drive if you’re using the actual disc) and switch to the E: drive.

If you’re using OSR 2.5, there’s a bug in the installer that prevents it from reading from the CD-ROM, so you’ll need to copy the contents of E:\WIN95 to the C: drive. Switch to the C: drive and invoke md WIN95 to make a WIN95 directory on the C: drive. Then, invoke copy e:\WIN95 c:\WIN95 to copy those contents from the CD to the C:\WIN95 folder for the installer. Once the copy operation is finished, switch back to the E: drive and run setup. Follow the prompts in the installer, and when you’re ready to reboot (the first time), make sure you eject the boot disk from A:.

At some point, you may be prompted to insert a different disk. This is where you will browse to the C:\WIN95 directory from earlier. The installer should see the *.cab file it needs, so click it and click “OK” to continue. At the end of the install process, you’ll need to reboot again.

Bloo doodledoo ding ding ding….

Installing Voodoo and S3 Drivers

If you don’t already have the drivers on a disk image, create a simple *.img file containing them in your disk image management software of choice. Mount this image in the emulator, and you’ll be able to install the drivers for the virtualized S3 video adapter and the Voodoo 3D acceleration.

Right-click the desktop, then click Properties. In the Desktop Properties dialog, go to the Settings tab and click “Advanced Settings”. On the Monitor tab, verify that “Plug and Play Monitor” is selected. Click the Adapter tab and the “Change…” button. Click the “Have Disk” button and browse to the CD image where the S3 drivers are located. Once that’s set, you’ll be prompted to reboot Windows again.

After rebooting, it’s finally time to install the Voodoo drivers. Open the CD image in Windows Explorer and run the Voodoo 2 executable to extract the files to your hard drive. Open the Device Manager and double-click on “PCI Multimedia Video Device”. Open the Driver tab and click the “Update Driver” button. Search for the driver, then browse to the folder where you extracted the Voodoo driver (probably c:\voodoo2). You’ll be prompted to insert a different disc, so browse to the Voodoo2 folder again and select the *.dll file that appears. Once the driver is finished installing, you’ll be prompted to reboot once again.

At this point, Windows 95 is ready to go. Fire up some Fury3 or Hover! and bask in the vintage goodness (or just be thankful that we don’t have to suffer this OS as a daily driver anymore)!

Sources:

Setting up PCem for Windows 95 games

Using Voodoo 2 emulation with PCem / 86Box

How To Use Guitar Hero/Rock Band Controllers in Windows 11

Author’s note: The original text of this article detailed a method that involved using an unsigned driver. In Windows 11, this requires disabling core memory protection and can create serious vulnerabilities on the machine. The official driver will work just fine in Windows 11 and is preferable to disabling any level of device security.

Clone Hero is the pinnacle of development in the “pretending to be a rock star by pressing buttons on toy instruments” genre of gaming, combining all songs from every Guitar Hero and Rock Band title into one open-source, customizable experience. Unfortunately, through some brilliant decision at Microsoft, the wireless guitar controllers for Rock Band and Guitar Hero no longer work with the official Xbox 360 wireless dongle. Unfortunately, it’s getting harder and harder to find official Xbox 360 wireless dongles since the Xbox One utilizes the Bluetooth protocol for its wireless connectivity.

Enter the Chinese Xbox 360 Wireless Receiver dongles that are advertised all over eBay.

They’re cheap, and they work, but they need a little jiggery-pokery to get started.

The first thing you’ll need is the official Microsoft drivers for the official wireless dongle. They’re somewhat difficult to find, but there is an archive available here. Extract the files for your version of Windows.

Plug in the dongle’s USB cable and open the Device Manager. The dongle should show up as “Other Devices > Unknown Device”. Right-click the device and open it’s properties. On the Details tab, look for the device’s hardware ID. It should list as 02A9, 0291, or 9244. Make note of the ID number.

Go back to the extracted driver archive and dig in until you find xusb21.cat and xusb21.inf. Open xusb21.inf in Notepad and use the Find-Replace function to locate all of the instances of “0719” and replace them with the hardware ID that you noted earlier. Rename xusb21.cat to something else. At this point, the official Microsoft driver is now an unsigned driver, and Windows will consider it a security threat. You may need to disable driver verification temporarily while you install the driver.

Back in the Device Manager, right-click the device and select “Update Driver Software”. Browse for your driver and point it to the modified xusb21.inf file. Windows will warn about using an unsigned driver. Push through and finish the installation. The device should now show up as “Xbox 360 Wireless Receiver for Windows” under the Xbox 360 Peripherals heading. Click “Browse my computer for drivers”, then “Let me pick from a list of available drivers on my computer”. From the list that opens, highlight “Xbox 360 Peripherals” and click the Next button. In the next list, highlight “Xbox 360 Wireless Receiver For Windows” and click the Next button. You may get a warning that the driver might be incompatible, but trudge through. Once the driver installation is complete, the receiver will work just fine for guitars, drums, keyboard, or even just the good ol’ wireless controller.

Sync your guitars like you would normally (push the Guide button on the guitar to turn it on, then press the button on the dongle, then press the Sync button on the guitar). The dongle can handle up to 4 wireless controllers for those party time supergroups! Rock on!

Sources:

https://www.s-config.com/chinese-xbox-360-wireless-receiver-driver-setup/
https://www.reddit.com/r/CloneHero/comments/jxatma/guide_how_to_get_it_working_connecting/

How To Get Burnout Paradise Running on PC

Burnout Paradise Remastered, while not the absolute best of the franchise (that distinction belongs squarely to Burnout Revenge), is still a great game and–as of this writing–the only one available on PC for online multiplayer. Unfortunately, the PC port suffers from inadequate support from Electronic Arts and can be persnickety to get running on systems without dedicated GPUs (i.e. laptops), even if the integrated graphics are superior to the recommended spec (as is the case with most contemporary mid-range systems)! Precious little documentation exists to help troubleshoot this title, and EA forum posts haven’t been updated in over 5 years, so it came down to a lot of digging through various sources, and a little trial-and-error hackery to finally get the game running. Being a Steam purchase, I had the added time limit of 2-hours running time to figure out an answer before submitting for a refund. 86 minutes of in-game time and countless opening strains of Guns N’ Roses eponymous metal track later, I finally figured out how to get this thing running like a champ!

Step One: Patching The Bugs Out

For whatever reason, Criterion and EA thought that having the webcam always on during the gameplay was a great idea. Unfortunately, the software support for the webcam was only half-baked, so many cameras on the market (especially integrated laptop cameras) were left unsupported. Fortunately, Bo98 has written a mod for BPR that fixes the webcam bug and several other issues that cause the game to crash during the initial loading screens.

You’ll want to download and install BPR Modder from Bo98’s website (in the case that it goes down someday, I’ll have a mirror available). From BPR Modder, install the Core Bugfixes mod (0.2.1 as of this writing). This should fix all of the instability issues with loading the game and connecting to the servers, and you should be able to see the Burnout Paradise Remastered main menu. If you’re still crashing before the opening cutscene, try this version of the patch. Just overwrite it in the C:\SteamLibrary\steamapps\common\BurnoutPR\mods folder. Select “Enter Paradise City” and see how far you get.

Step Two: Entering Paradise City

Now we get into the GPU issues. Weirdly, the only place in the game that has severe rendering issues is the opening cutscene that explains the concept of Paradise City and its different districts. On my machine, the cutscene either shows no video (and subsequently hangs at the end of the narration) or just plain crashes when it tries to show the video. Unfortunately, there is absolutely no way to bypass the video if you haven’t played before–no button to skip or settings to prevent it from playing. The remedy is to change your savegame file to one that shows you having at least 1 second of game time. Noderunner has made a suitable file available for download from their Google Drive (again, I’ll have a mirror if it goes down). Download the file and save it to the appropriate directory. On Windows, that’s C:\Users\[username]\AppData\Local\Criterion Games\Burnout Paradise Remastered\Save. Restart the game, and you should be able to get into the engine.

Step Three: Adjusting The Graphics

Yeah, those Intel Iris Xe graphics are way above what the game wants in order to run at 1080p, but you’re still using integrated graphics, so your processor is going to be working double-time to take care of running the game as well! If you are able to get to the Junkyard, but still have crashes, use the BurnoutPR Config Tool (modded by Bo98) to dial down the graphics a smidge. I run mine at “Medium” quality and no anti-aliasing and it’s smoother than owl shit. For the record, the game still looks great at “Low” quality. I would call it Xbox 360 quality versus whatever’s out now.

Step Four: Optional Fixes

I’ve had various levels of success here, but I’m putting these in for my own records. I’m using the following launch options for Steam: -safe -multithread -skipvideos which launch the game in Safe Mode, Multi-thread mode, and skips the video cutscenes respectively. Cutscenes still play, so I’m not entirely sure how much this changes anything. The game is stable, so I’m disinclined to experiment more than I have to. One last thing I would recommend is deactivating the EA/Origin DRM app’s overlay. This can be done in the app’s settings, and should make life a lot easier playing under Steam. The Steam overlay has also been known to cause issues, so it may be useful to deactivate as well.

I would like to express my appreciation to all the disparate folks (Bo98, Noderunner, burninrubber0, and Decclo) whose insight I was able to pull together to get this game running. It’s great fun, and if you can find it on sale with all the DLC included (the Legendary Cars, Paradise Bikes, and Big Surf Island), it’s a great buy. Now the only crashes I experience are the ones I cause in-game!

2014 Mazda CX-5 Maintenance

The Mazda dealership wanted about $1000 to change the oil, the air filters, the spark plugs, and clean the corrosion off the battery terminals. I laughed and declared that I, too, own a set of wrenches!

I must note that I do prefer Mazda doing the oil change. It saves me time and effort, and I don’t have to worry about being under the car if the ground starts shaking. Yes, please, put the car on a lift, check the brakes, top off the fluids, and do your factory walkaround while I get some paid work done! I’m just not going to pay you a premium to do easy maintenance work. Don’t get fleeced by the dealership, and save your mechanic’s time and expertise for the big jobs!

How To Change Spark Plugs

The 2014-2020 Mazda Skyactiv engines feature a plug-on-coil design that makes changing plugs incredibly simple. Just remove each coil pack but removing the retaining nut with an 8mm socket and lifting the coil pack off the plug well. Use a 14mm deep socket on an extension to reach the plug and unscrew it from the cylinder, then replace the old plugs with new NGK Iridium IX plugs. (As best I can tell, the OEM Mazda plugs are NGK Iridium plugs). Carefully reseat the coil packs on the plugs and replace the retaining nuts.

How To Change The Engine Air Filter

Find the air box (in this car, it’s at the front of the engine compartment on the driver’s side) and unclip the retaining clips to open. Remove the old filter and replace it with the new one (making sure the air is flowing in the correct direction). Reseat the air box lid and replace the clips.

How To Change The Cabin Air Filter

The cabin air filter is almost universally located behind the glove compartment. Open the glove compartment and squeeze inward on the sides to remove. Locate the cabin air filter, then simply remove and replace. Gently replace the glove box, making sure the hinges are aligned.

How To Clean Battery Terminals

I didn’t make a video for this part of the project because it seemed too much a waste of my time and yours. Auto parts stores sell an aerosol battery terminal cleaner that reacts with acid to neutralize it. Follow the directions on the can, then rinse away (in a manner conforming to local EPA regulations–don’t let it wash into a waterway). Just be sure that your cells aren’t exposed or you could neutralize all the electrolyte in the battery, rendering it intert.

A Serial Terminal For Windows Terminal

Since switching to Windows 11, I have fallen in love with Windows Terminal–the built-from-the-ground-up terminal emulator for Windows that combines everything that I loved about Linux and MacOS with the functionality of tabbed windows and a serious dose of customization. However, because much of my command line work falls into communicating with an external device over serial, I wanted to be able to keep that workflow within Windows Terminal like I’m used to doing already. In other words, I didn’t want to have to resort to using a separate GUI like PuTTY when a command-line tool like Screen or Minicom would do just fine. The problem is that, since the removal of HyperTerminal in Windows Vista, Windows has not included a CLI solution for serial communication (which is kinda weird because Telnet is still buried in Windows 11; if the reasoning was because obsolescence, you’d think that Telnet would also get the axe).

Now, since I have Ubuntu installed, I could just install Screen or Minicom and call it a day, but WSL 2 does not support serial communication. If I wanted to use those tools, I would either need to change the WSL version every time I wanted to use the serial port or install another instance of Linux under WSL 1. I mean, it works, but I really just felt it inefficient to have to fire up Debian (the install is smaller than Ubuntu) just so I could use Minicom.

After a little more digging, I found Makerdiary’s Terminal-S. It’s a simple serial terminal written in Python that can be compiled as a self-contained exe. This little gem was exactly what I was looking for in terms of functionality! It automatically connects to the COM port (or drops a list of available ports) and connects using some default settings for baud rate, stopbit, and parity. I can fire up Windows Terminal, invoke the command in PowerShell, and I’m good to go!

Windows Serial Terminal

But this is Windows Terminal, and I have this lovely menu of drop-down presets that will automatically spawn the environment of my choice with some lovely aesthetic theming. So, I want to be able to just click on a new tab and get that full retro terminal feel without needing to pretend I’m even in Windows! What I need to do is alter the program just a smidge so that instead of looking for flags in the command-line structure (ie -b for setting baud rate), the program will just ask me what settings I want to use (including some defaults for simplicity). To do this, I simply altered the @click.command section to only look for serial ports and moved the connection settings to a series of prompts in the main function, like so:

"""
Terminal for serial port

Requirement:

    + pyserial
    + colorama
    + py-getch
    + click
"""

import os
if os.name == 'nt':
    os.system('title Serial Console')

from collections import deque
import sys
import threading

import colorama
import click
import serial
from serial.tools import list_ports


def run(port, baudrate = 115200, parity='N', stopbits=1):
    try:
        device = serial.Serial(port=port,
                                baudrate=baudrate,
                                bytesize=8,
                                parity=parity,
                                stopbits=stopbits,
                                timeout=0.1)
    except:
        print('--- Failed to open {} ---'.format(port))
        return 0

    print('--- {} is connected. Press Ctrl+] to quit ---'.format(port))
    queue = deque()
    def read_input():
        if os.name == 'nt':
            from msvcrt import getch
        else:
            import tty
            import termios
            stdin_fd = sys.stdin.fileno()
            tty_attr = termios.tcgetattr(stdin_fd)
            tty.setraw(stdin_fd)
            getch = lambda: sys.stdin.read(1).encode()

        while device.is_open:
            ch = getch()
            # print(ch)
            if ch == b'\x1d':                   # 'ctrl + ]' to quit
                break
            if ch == b'\x00' or ch == b'\xe0':  # arrow keys' escape sequences
                ch2 = getch()
                esc_dict = { b'H': b'A', b'P': b'B', b'M': b'C', b'K': b'D', b'G': b'H', b'O': b'F' }
                if ch2 in esc_dict:
                    queue.append(b'\x1b[' + esc_dict[ch2])
                else:
                    queue.append(ch + ch2)
            else:  
                queue.append(ch)

        if os.name != 'nt':
            termios.tcsetattr(stdin_fd, termios.TCSADRAIN, tty_attr)

    colorama.init()

    thread = threading.Thread(target=read_input)
    thread.start()
    while thread.is_alive():
        try:
            length = len(queue)
            if length > 0:
                device.write(b''.join(queue.popleft() for _ in range(length)))

            line = device.readline()
            if line:
                print(line.decode(errors='replace'), end='', flush=True)
        except IOError:
            print('--- {} is disconnected ---'.format(port))
            break

    device.close()
    if thread.is_alive():
        print('--- Press R to reconnect the device, or press Enter to exit ---')
        thread.join()
        if queue and queue[0] in (b'r', b'R'):
            return 1
    return 0

@click.command()
@click.option('-p', '--port', default=None, help='serial port name')
@click.option('-l', is_flag=True, help='list serial ports')

def main(port, l):
    port is None
    if port is None:
        ports = list_ports.comports()
        if not ports:
            print('--- No serial port available ---')
            return
        if len(ports) == 1:
            port = ports[0][0]
        else:
            print('--- Available Ports ----')
            for i, v in enumerate(ports):
                print('---  {}: {} {}'.format(i, v[0], v[2]))
            if l:
                return
            raw = input('--- Select port index: ')
            try:
                n = int(raw)
                port = ports[n][0]
            except:
                return
    baudrate = input("Enter baud rate (Default 115200): ")
    if (len(baudrate) == 0):
        baudrate = 115200
    parity = input("Enter parity [N,E,O,S,M] (Default N): ")
    if (len(parity) == 0):
        parity = "N"
    stopbits = input("Enter stop bit (Default 1): ")
    if (len(stopbits) == 0):
        stopbits = 1    
    while run(port, baudrate, parity, stopbits):
        pass

if __name__ == "__main__":
    main()

Of course, it took me a little bit to deconstruct the program (as well as re-learn Python, which I hadn’t really used in any significant capacity for half a decade at least), but now I have it working exactly how I want it to work, and it feels right! Of course, I had never used Python on Windows before, either, so wrapping my head around PowerShell has been enlightening as well (Yes, I’m late to the PowerShell party, so I’m making up for it). Once I figured out how to use Pyinstaller (after remembering how to set a PATH variable in Windows), then I just have to drop the portable EXE file into a nice, out of the way place in Windows (might as well put it in a folder in C:) and make sure that folder is added to the PATH variable.

Add a folder to PATH variable

Adding a folder or application to the global PATH variable is a pretty simple proposition in Windows. From Windows Explorer, right-click on “This PC” and select “Properties”. This will bring up the settings dialog for System > About. Just under the “Device Specifications” section, click “Advanced System Settings” to bring up the traditional System Properties window. Click on the “Advanced” tab, then the “Environment Variables” button at the bottom of the window.

The “Environment Variables” window is divided into to groups: one for the current user and one for the system. In the system group dialog, find and double-click the line for “Path” to edit it. Click the “New” button to add a new line and type in the path for the folder or application you wish to add to the system PATH. When you’re done, click “OK” to close the window and save, then click “OK” to close the Environment Variables window, and finally click “OK” to close the System Properties window.

Customize Windows Terminal

In Windows Terminal, open the settings dialog and click “Add A New Profile”. Fill in the settings as appropriate. I’ve posted mine as a model:


Retrotacular

Of course, the real draw here is giving the terminal tab a lovely old-school green phosphor look which we can do either using the settings GUI to turn on the “Retro terminal effects” (this setting simulates CRT scan lines and gives a nice anti-alias that simulates the phosphorescent glow of the characters on the monitor). I’m using the Cascadia Mono font at 16pt weight to get the look I’m going for and the “Vintage” cursor style will round everything out nicely. For the color scheme, add the following block of code to the settings JSON file, then enable the new “Green Phosphor” color scheme.

{
            "background": "#000000",
            "black": "#000000",
            "blue": "#00FF00",
            "brightBlack": "#00FF00",
            "brightBlue": "#00FF00",
            "brightCyan": "#00FF00",
            "brightGreen": "#00FF00",
            "brightPurple": "#00FF00",
            "brightRed": "#00FF00",
            "brightWhite": "#00FF00",
            "brightYellow": "#00FF00",
            "cursorColor": "#00FF00",
            "cyan": "#00FF00",
            "foreground": "#00FF00",
            "green": "#00FF00",
            "name": "Green Phosphor",
            "purple": "#00FF00",
            "red": "#00FF00",
            "selectionBackground": "#FFFFFF",
            "white": "#00FF00",
            "yellow": "#00FF00"
        }

From here, everything is ready to go! Connect a serial device, fire up the terminal, and you’re off to the races!

How To Install Android Apps On Windows 11 Without Amazon

Microsoft has really leaned into the whole open source world since Staya Nadella took over in 2014, and that’s been pretty wonderful if you ask me. I am completely enamored with their use of GitHub for developing Windows modules, and especially with the Windows Subsystem for Linux that lets me run all my favorite Linux tools right from the convenience of Windows Terminal (which is also pretty awesome, by the way). While Apple has doubled-down on the closed-off, walled-garden ecosystem that they’ve been working on since the debut of the iPhone, Microsoft has gone in the opposite direction (to great benefit), embracing the same kinds of interoperability with Android devices through the Your Phone app. The only piece of the puzzle that’s been missing is the ability to run Android apps directly on the desktop which is where the new Windows Subsystem for Android comes in. Unfortunately, the system is immediately hobbled by having only the Amazon app store available, so we’ll need a way to get any and all apps (and app stores) installed. I generally prefer starting from the Google Play store (which has its own caveats, of course), so we’ll need to go through an alternative installation process to set up WSA rather than the straightforward installation via the Microsoft Store.

This tutorial is based on work previously put together by the WSA Community on GitHub with my own commentary to clarify or expand on the subject matter.

Install Windows Subsystem for Android and Windows Subsystem for Linux from the Microsoft Store

The first step in getting the Google version of WSA is to install the stock version (with Amazon) from the Microsoft Store. There are several dependencies that WSA requires, so this is the quickest and easiest way to have them installed on your machine. Once WSA is installed, you can skip signing into the Amazon App Store and uninstall the stock WSA.

To compile a custom version of WSA, we’re going to need a few tools that run exclusively in Linux (Android being based on the Linux kernel, but you knew that). Grab your preferred flavor from the Microsoft Store. I’m using Ubuntu because that’s the one I’m most familiar with (being my daily driver for half a decade). Once you have WSL installed, open a PowerShell terminal and type wsl --list --verbose to verify that your distro is running WSL version 2. If, for whatever reason, your distro is running WSL version 1, you’ll need to stop the WSL with wsl --shutdown and type the following command:

wsl --set-version <distro name> 2 where <distro name> is the name of your distro as listed when you ran the –list command earlier. This will take just a few moments, and you’ll be ready to continue!

Install Linux packages

If you’ve already set up your Linux distro as a tab in Windows Terminal, good on you! Open that tab and get ready to Bash. For the rest of you, start your distro by invoking the following in a PowerShell terminal:

wsl -d <distro name>

Now you’ve got your Linux distro up and running, so the following commands will be entered at the $ prompt (instead of the Windows > prompt):
sudo apt update
sudo apt install unzip lzip

Prepare Installation Folder

Back in Windows Explorer, create a folder at C:\WSA. This is going to be the working folder for our installation. Now, we need to download the installation package. However, since we’re going to be modifying the package, we can’t just grab it from the Microsoft Store (that’s what we did earlier). You’re also going to want to install a Zip archive manager like 7Zip or PeaZip.

Download the WSA installation package

We’re going to use a link generator service to get the installation package from the Microsoft Store’s repository. Navigate to https://store.rg-adguard.net and enter the following settings before clicking the check mark:

ProductID: 9P3395VX91NR

RP: Fast

You’ll be presented with a list of all the files related to that Product ID, but we’re looking for the *.msixbundle file extension associated with WindowsSubsystemForAndroid. The file should measure around 1.3GB. Download the package file to your C:\WSA folder and open it with your Zip manager. You’re going to see a lot of files with the *.msix extension, but sort them by size to find the biggest files. Find the one that matches your OS architecture (for example, WsaPackage_X.X.XXXXX.X_x64_Release-Nightly.msix for a 64-bit Windows) and extract it.

Now, extract the contents of the *.msix file to a new folder within C:\WSA. Locate and delete the following:

“AppxBlockMap.xml”

“AppxSignature.p7x”

“[Content_Types].xml”

and delete the “AppxMetadata” folder.

Download OpenGApps

Navigate to https://opengapps.org/ and download the Android 11.0 Pico variant for your architecture.

Save the Zip file in the C:\WSA folder, but don’t extract it.

Clone the GitHub Repo and Populate Directories

Fire up your WSL distro and mount your C:\WSA directrory so you can clone the WSAGAScript repo by running the following at your WSL ($) prompt:
cd /mnt/c/WSA
git clone https://github.com/WSA-Community/WSAGAScript

(NOTE: If this repository fails, I have a fork at https://github.com/airbornesurfer/WSAGAScript)

In Windows Explorer, go back to your extracted WsaPackage folder (the one you deleted files from earlier) and copy the following files into the C:\WSA\WSAGAScript#IMAGES folder:

product.img

system.img

system_ext.img

vendor.img

Lastly, copy the GApps Zip file downloaded earlier into C:\WSA\WSAGAScript#GAPPS (again, do not extract it).

Create the New Installation Package

Check the “VARIABLES.sh” file to verify that your architecture is set correctly, then set the permissions for the scripts that will create the new installation images. From your WSL terminal (you should still be in mnt/c/WSA/WSAGAScript), invoke the following command:

chmod +x *.sh

You can verify the scripts are now executable by invoking ls -l and checking that the *.sh files show “-rwxrwxrwx”. If all is set, then execute the scripts by invoking the following:

./extract_gapps_pico.sh
sudo ./extend_and_mount_images.sh
sudo ./apply.sh
sudo ./unmount_images.sh

Once complete, move the *.img files from the C:\WSA\WSAGAScript#IMAGES folder back to the WsaPackage folder you previously copied them from.

Register the New Installation Package and Install

Open Windows Developer Settings (search “Developer Settings” from the Start Menu) and enable Developer Mode. Close Windows Terminal and open a new PowerShell Terminal as Administrator, then invoke the following command: Add-AppxPackage -Register <path-to-extracted-msix>\AppxManifest.xml where <path-to-extracted-msix> is the path to the WsaPackage folder inside C:\WSA.

WSA will now install with GApps. Once complete, sign into the Google Play Store and install “Android System WebView” to make sure your apps don’t crash.

Restoring Wii Online Services With RiiConnect24 and Wiimmfi

There is something kinda fun about those early internet apps that landed on the Wii. They’re definitely not worth anything more than historical curiosity at this point, but I think they’re still worth having around for play with. Then again, I like to use a 40-year-old luggable to play games on because it’s interesting, so maybe I’m not the best judge of this.

Restore online services with RiiConnect24

First, hit up the RiiConnect24 GitHub and download the latest version of the WAD patcher. It’s a pretty straightforward endeavor from there to just run the batch or sh file (depending on your OS flavor preference). Just follow the directions and be patient.

Once the patcher has done its job, return your SD card to the Wii and launch Wii Mod Lite from the Homebrew Channel. Like we did with the USB Loader GX channel WAD, select the files you want to install, then press A twice to install the batch. One thing to note: there may be an update to one of the service channels listed in the batch with the base channel WAD. Do NOT attempt to install the update WAD with the batch as it will likely fail. Exclude the update, install the batch, then install the update WAD. If you forget, you’ll need to uninstall both the update and the base WAD, then install one at a time.

Patching Wii Mail

From the Homebrew Channel, launch the RiiConnect24 Mail Patcher. Follow the instructions on screen, then press HOME when it’s finished. You’ve got mail!

Connecting to the new servers

Just like we did for str2hax, we’ll need to change the Wii’s DNS servers. Go to Wii Settings, Internet, and Connection Settings, then scroll to the “Auto-Obtain DNS” page. Select “No” then “Advanced Options” and enter 164.132.44.106 as the primary DNS and 1.1.1.1 as the secondary DNS.

Click “Confirm” and “Save” then “OK” to perform the connection test. Of course, don’t update the Wii.

Return to the Settings menu, and select “WiiConnect24” to make sure that “WiiConnect24” and “Standby Connection” are both enabled.

Finally, return to the “Internet” section and read/agree to the User Agreement.

Enable Wiimmfi for online play

Since Nintendo shuttered the Nintendo Wi-Fi Connection, officially-sanctioned online play has been dead. However, thanks to dedicated fans of the system, robust online play still exists on Wiimmfi’s private servers. You’ll need to enable these in a few different places:

For disc-based games, you’ll need the Priiloader patch. Launch Priiloader by holding RESET and powering on the Wii. Select “System Menu Hacks” and enable “Wiimmfi Patch v4”. Save settings and exit.

For games loaded from hard drive, USB Loader GX has support for Wiimmfi built in. The global loader options will have a selection for “Private Server” that can be set to Wiimmfi. Save those settings and USB Loader GX will patch each game when it runs!

For WiiWare titles, you can use the RiiConnect24 WAD patcher as described above, then reinstall the patched WAD with Wii Mod Lite.

How To Install USB Loader GX on Wii

Now that we have The Homebrew Channel available to us, we can install a few niceties that can breathe a little life back into the unsupported mid-aughts console. First among these, we’ll need the ability to run custom firmware for the Wii (referred to as IOS). To do this, we’ll need the dx2 cIOS Installer. Download the application, unzip the archive, and place it in the apps folder of the SD card. Once the SD card is in the Wii, you can run the installer from The Homebrew Channel.

Install custom firmware on the Wii

Once the application loads, press A to continue, then match the settings as seen below:

Select cIOS: v10 beta52 d2x-v10-beta52

Select cIOS base: 57

Select cIOS slot: 249

Select cIOS version: 65535

Press A twice to install, then press A again to install the next cIOS:

Select cIOS: v10 beta52 d2x-v10-beta52

Select cIOS base: 56

Select cIOS slot: 250

Select cIOS version: 65535

Again, press A twice to install, then press A again to install the final cIOS needed:

Select cIOS: v10 beta52 d2x-v10-beta52

Select cIOS base: 38

Select cIOS slot: 251

Select cIOS version: 65535

Press A twice to install, then B to exit once completed.

Install USB Loader GX through Homebrew Browser

Download Homebrew Browser and place on the SD card like with the previous apps. Back on the Wii, launch The Homebrew Channel and select Homebrew Browser. At the very least, you’ll want to install USB Loader GX, Wii Mod Lite, and Nintendont. USB Loader GX is a full-fledged system menu replacement for Wii (and can be launched at boot through Priiloader) that will launch backup titles from a USB hard drive as well as install games to the hard drive. Wii Mod Lite will let you install custom channels to the system menu. Nintendont works inside USB Loader GX to handle launching GameCube games. Both apps are listed under the “Utilities” heading and should be at the very top (sort by popularity). Once the apps are installed, you can exit the Homebrew Browser.

A few notes about using USB Loader GX

USB Loader GX can be launched from the Homebrew Channel or through Priiloader. To launch from Priiloader, you’ll have to point the “Installed File” setting to the application and set the auto boot to “Installed File”.

The loader takes a few seconds longer than the stock Wii system menu to load because it’s checking for a USB hard drive. Also: make sure to use a USB hard drive. Flash drives tend to not work with USB Loader GX.

If a game does not load from the hard drive, try using a different cIOS. Select the problematic game, then click “Settings”. Click “Game Load”, then “Game IOS”. Enter the IOS you wish to try (249, 250, or 251), then click “OK”. Return to the banner screen and attempt to load the game. If the game doesn’t load, rinse and repeat. GBATemp has a pretty extensive compatibility list available here.

Installing USB Loader GX as a channel

If you prefer to keep the stock system menu on the Wii, you can still easily load USB Loader GX as a channel (saving you the step of having to go through The Homebrew Channel to launch). To do this, you’ll need to install the forwarder WAD. Download the WAD from the website and drop it in a folder called “wads” on your SD card. From The Homebrew Channel, launch Wii Mod Lite. Use the D-pad to select “WAD Manager”, then navigate to the wads folder on the SD card. Highlight the WAD file that you want to install and press A twice to install. Once installed, use the HOME button to return to the system menu. USB Loader GX will now appear as a channel!