Exploring the basics of PlayStation 2 soft-modding with FreeMCBoot and Open PS2 Loader (OPL)

It’s been possible, even downright easy, to soft-mod a PlayStation 2 for years now. And yet, it never really occurred to me to try to do it. Why is that? Maybe it’s because my PS2 has spent a decade in storage, in favor of a backwards compatible PS3. Or maybe because the PS2’s peak was in an era where I was less active with video games. Or maybe the system just never really captured my imagination. I still distinctly remember getting one on launch night, playing some SSX and TimeSplitters and thinking “that’s it?” It felt like a letdown after how mind-blowing the Dreamcast was on release the year before.

Regardless of my own interest in it, the PS2 is a system that really came into its own after a few years on the market and is undeniably one of the biggest successes the industry has ever seen, so even I ended up with a nice collection of games for it. For whatever reason, I recently took an interest in exploring it more. And exploring it more meant modding it. (Really, the true impetus for this project was probably that I’d been wanting to try out Gregory Horror Show, but didn’t have a PAL system to play it on!)

So with that out of the way, let’s document my setup for future reference or for anyone else who might be interested in doing something similar:

Target State

My goal was to have a handful of unique, rare, or otherwise interesting games available to play on my launch-day (NTSC, SCPH-30001) PS2 without needing to open the system or do any physical or permanent modifications. I wanted to be able to play games from any region without having to keep a stack of discs on hand and also wanted to explore interesting homebrew.

The Materials

This took a mix of items I already had on hand, plus a couple of cheap new additions to “the lab.” In all, I spent about $25 – remarkably cheap for everything the system is now capable of doing. Here’s what it took:

  • PlayStation 2 system (cost: already had) – Like I said above, this is the system I’ve had since launch day in October 2000. I connect it to a 32″ JVC D-Series via component cables. There’s nothing else particularly remarkable about it.
  • FreeMCBoot 8MB memory card (cost: <$10 shipped) – FreeMCBoot is a “Free Memory Card Boot” program that fully unlocks your PS2 at boot time, as long as it’s loaded on a memory card inserted into your system. Want to go back to a stock system? No problem, just take out the memory card! It’s an extraordinarily easy and non-invasive mod and remarkable in its effectiveness. It’s possible to make your own FreeMCBoot card, but it’s a complicated setup and you’re best off using a spare memory card dedicated to it anyway, so why not just buy one pre-loaded? They’re dirt cheap on eBay – less than $10.
  • An old 60 GB IDE hard drive (cost: already had) – I used to have an old Pentium 3, circa the year 2000. It was a high school graduation gift from my parents. I later added a second hard drive to it. I recycled that PC long ago, but I pulled the HDD when I did and it’s been in storage ever since. What a great way to put it back to use, don’t you think?
  • Official PS2 HDD/Network Adapter (cost: ~$15+shipping) – This is something I briefly wanted back in the day because I was convinced I wanted to play the original SOCOM online after trying the demo. Then I never got around to it. I guess I finally found an excuse to get one! A used one was surprisingly cheap. I’m not sure why I thought this would cost more than it did!
  • USB thumb drive (cost: already had) – I’m sure you already have one of these. Probably several. So do I. In fact, mine was free. You probably have free ones, too.
  • IDE/SATA to USB 3.0 adapter (cost: already had this one from Amazon, which runs $16) – I got this a few years ago for backing up old hard drives. Super useful and convenient. There are multiple ways to get data onto your PS2 HDD once it’s modded, like via a network connection, but connected to your PC via USB is absolutely the fastest way to move around large files.

The Procedure

1. Perform the Mod

Plug your FreeMCBoot card into either memory card slot and turn on the system. That’s it. The mod is done. Whew – that was hard work, wasn’t it? Your memory card probably came with some pre-installed utilities and emulators, so poke around a bit and see what’s possible. Hopefully it came with uLaunchELF and Open PS2 Loader (OPL) already installed. If not, add them by copying the .ELF files over to your memory card and running the FreeMcBoot Configurator to add them to the launch menu. I’ll leave that exercise to you, since it’s a procedure best documented elsewhere, and this guide assumes they’re probably already installed. At this point, if you really wanted to, you could even start running games off of a USB drive. That isn’t a great experience, though, since the USB ports on the PS2 are so slow. So let’s continue on to the next steps…

2. Format the HDD

With your PS2 powered off and your HDD’s jumper set to Master (note: this is important, don’t skip this!), plug the HDD and Network adapter into your PS2. Boot the system and run uLaunchELF. Go to File Browser –> MISC –> HddManager. In the HDD Manager program, hit R1 and choose “Format.” This will format your drive to be readable by the PS2. After this, reboot and launch OPL. Launching OPL will automatically create the directory structure it needs on your hard drive. With those two steps out of the way, you should be able to browse your HDD in the uLaunchELF File Browser and you’ll see a “+OPL/” directory at its root.

3. Load some games

Unfortunately, you can’t just copy ISO files over to your HDD like any other file and have them be playable. You have to properly install them. So, power your system down, remove the HDD, and place the jumper into Slave mode. Connect the drive to your PC via your USB adapter. (This part is finicky for me, sometimes the drive powers on properly, sometimes it doesn’t. Sometimes apps can recognize it, sometimes they can’t. With my adapter, I need to keep trying until I hear the usual Windows USB chime, without an additional drive appearing in Windows Explorer.) Once the HDD is properly connected, run hdl_dumb (note: run as Administrator!) to install whatever ISOs you happen to have on hand. (You’re backing up your own games, right?) This process is self-explanatory, just follow the obvious functions in the UI.

Installing games to the HDD via HDL Dumb (and an IDE to USB adapter for your PC).

4. Add some fancy artwork

You want your loader menu to look nice when you’re picking out what games to play, don’t you? After your games are installed, run OPL Manager (again, run as Administrator) to get box art, disc art, screenshots, and more. The program can auto-recognize which games are installed by choosing “Get Game List” from the “Local HDD Options” menu. You can automatically download the art you want for your installed games, but note that this process is not actually putting the artwork onto the PS2 HDD at this point. You’ll have to do a transfer process to move everything over. There’s a utility called OPL Manager HDD ART Batcher that can do this automatically, but I found it finicky and it would often skip files (especially disc art, for some reason). Instead, I recommend reinstalling the HDD into your PS2 and manually copying the contents of your OPL Manager hdl_hdd/ART directory from your PC to the corresponding directory on your PS2 HDD with a thumb drive via the uLaunchELF File Browser.

5. Configure OPL

You’re almost done! The next crucial step is to get OPL to recognize your HDD when you launch it. So run OPL, go into the Settings menu, and set “HDD Device Start Mode” to “Auto.” Save your settings and from now on, OPL should automatically recognize your HDD and any games installed on it when you launch it.

At this point, you have a fully functioning mod in place, it’s just a matter of setting up OPL to get the look and feel you want. I recommend exploring the various themes that are available for the utility. They can be easily installed by copying over to your +OPL/THM directory via USB drive. (I particularly like the “stone” theme.) Tinker around with whatever other settings you want – for example, the “Enable Write Operations” flag will allow you to delete games or edit their names straight from OPL. Just don’t forget to save your settings each time you make a change.

Also note that a fair amount of configuration is available at the game level. You can do things like change the video mode (useful for playing PAL games in NTSC-land) and use “virtual memory cards” if your memory card is full. Poke around, see what there is to see, and make the setup your own.


And there you have it! At this point, you have a fully modded PS2 with a collection of games and a nice hard drive loader front-end to browse and launch them. Feel free to explore what else you can do with a modded system, but if I’m completely honest, there’s not much I recommend. Yeah, there are emulators and Doom ports and such, but there are a million and one different devices that can do a better job of those things now. Modding a PS2 these days is really all about running games from a hard drive. But hey, that’s a pretty good use if you ask me!

Running N64 homebrew the absurd way: The GameShark Pro loader

Do you really, really want to play homebrew on your original N64 hardware? Is a flash cart just too pedestrian and mainstream for you? Do you posses a GameShark Pro, a 4MB Expansion Pak, and a brain disease that makes you enjoy doing things the hard way? Well, I sure do! And hoo boy, do I have a project for you…

Read on, brave souls, for herein lies the story of how I played a commercial homebrew NES game (legally purchased electronically from Steam) on my N64 via an NES emulator, which I loaded with a GameShark Pro that was interfaced to my Windows 10 PC via a very specific USB-to-Parallel adapter, that was then passed through to a lubuntu virtual machine running via VirtualBox, containing a USB GameShark homebrew loader program.

Doesn’t that sound fun?

This method made the rounds on the web a couple of years ago, but nobody really described how to do it in layman’s terms and the information was a bit scattered. So when I found out about it, it still took some piecing together. Let’s rectify that and make the method as clear as possible. Let’s get started!

The Background

What You’ll Need

  • An original N64 with a 4MB Expansion Pak installed
  • A GameShark Pro with a functional parallel port
  • A USB-to-Parallel adapter based off of a MosChip 7705 bridge
  • The ability to run Linux (I prefer lubuntu on VirtualBox for these sorts of projects)
  • A copy of gs_libusb
  • Your favorite NES ROM (I highly recommend Micro Mages! The Steam version even includes a legal NES ROM that works perfectly for this project.)

The basic goal for this project is that we need to run a Linux application called “gs_libusb” to transfer programs to our GameShark Pro. The tough part is how to get them talking to each other.

The hardest part of making this work might be sourcing the USB-to-Parallel adapter. Any old adapter off of Amazon or eBay or whatever just won’t work. As I mentioned in my post about connecting the GameShark to a PC, it’s only possible to do this with an adapter based off of a MosChip MCS7705 bridge (in fact, gs_libusb is hard-coded to look for it). I don’t know how to identify whether a random cable has this chip, so hunting one down is hard. I did manage to figure out that the USB-1475 manufactured by Cables Unlimited contains this chip and works well. These specific cables don’t seem to be produced anymore and are hard to come by these days. If anyone knows of other cables that contain the right chip, please let me know by leaving a comment.

Next, you’ll need to have the right version of the GameShark Pro. Versions 3.1, 3.2, and 3.3 all came with parallel ports on the back. All versions of 3.1 and 3.2 should work, but only certain versions of 3.3 carts will work. With version 3.3, some contain a working parallel port and some don’t. Usually, GameSharks with a speckled-looking case will work. The folks over at Micro-64 have a good explanation of the difference. (That article also explains how to load homebrew with legacy PC hardware, so check it out if you have an old Windows 98 machine lying around and can’t find the USB-to-Parallel adapter that’s needed for this method.)

Enough rambling, let’s get to it. Here’s the method…

The Method

Step 1: Set up your virtual machine

I won’t go into much depth here about how to set up a virtual machine, I’ll just reiterate that I like lubuntu and Virtual Box for projects like this. Go through the normal setup process for any virtual machine and you’ll be good to go. Here are the important configuration changes you’ll need to make once your install is complete:

  • Install the Virtual Box Extension Pack: By default, Virtual Box only supports USB 1.1. Installing the Extension Pack will allow us to configure USB 3.0.
  • Set your virtual machine to use USB 3.0: Without this step, you’ll be relegated to USB 1.1 and probably get a lot of very frustrating USB timeout errors when you attempt to load anything to the N64. Once the Extension Pack is installed, edit the USB settings for your virtual machine to set them to USB 3.0 mode. Then, with the USB-to-Parallel adapter plugged into your host machine, add a USB device filter for “MosChip Semiconductor MCS7705 Parallel port adapter [0100].” This is what will allow the virtual machine to see your adapter. Or, alternately, add a blank filter to allow all USB devices to pass through.
  • Optional – Install the VirtualBox Guest Additions for Linux: This isn’t strictly necessary, it just makes life easier by allowing you to copy/paste files from Windows to Linux and share a clipboard. Instructions for the install are at the VirtualBox site. I highly recommend doing this, unless you prefer to map network drives to do file sharing between systems.

Step 2: Compile gs_libusb

This is the loader program that will send files to the GameShark Pro, but it’s just provided as source code and needs to be compiled on your system. It’s not too hard, just follow these steps on your Linux machine:

  • Install libusb 1.0 dev libraries: libusb is a tool that allows programs to communicate with USB devices. Your system may have the binaries installed already, but we’ll need the libraries to compile our own code with it. To get them, open a terminal prompt and enter the following commands…
sudo apt-get update
sudo apt-get install libusb-1.0-0-dev
  • Download and extract the gs_libusb project: Grab the whole project from the Github page (download it as a .zip) and extract it to a reasonable directory somewhere, such as your home directory.
  • Compile the code: Open a terminal window in the root gs_libusb-master directory and type the following commands…
sudo make clean
sudo make

Assuming your libusb 1.0 libraries installed correctly, the compile should run quickly, and that’s all there is to this step. You’ll see warnings, but they can be safely ignored.

Step 3: Prepare your N64

Now we need to make sure that the N64 is ready to accept a program we send it. Just do the following…

  • Ensure your N64 has a 4MB Expansion Pak installed: This step is absolutely required, this simply won’t work without an Expansion Pak.
  • Plug in your GameShark: Use a common game, such as Super Mario 64 or Pilotwings 64, in the top slot. Avoid anything that uses the Expansion Pak memory.
  • Plug the USB-to-Parallel adapter into the GameShark: This should be self-explanatory.
  • Boot your game: Power on your N64 and choose to start your game. Make sure to turn the Code Generator ON and start the game Without Cheats. Once the game begins, your GameShark is ready and waiting for commands on the parallel port! (I typically use Super Mario 64, loaded up to the Select File screen.)

Step 4: Run the loader

Finally, the real step. With our VM prepared, gs_libusb compiled, and our N64 waiting patiently, let’s send it something to run!

  • Plug the USB-to-Parallel adapter into your PC: Be careful here and ensure that the VM actually picks it up and sees it. Run the following command at the terminal to ensure the MCS7705 is listed. If it’s not, check your VM’s USB settings and make sure that your host PC hasn’t “claimed” the device. (Unplug it and plug it back in with the VM running.)
  • Copy your ROM to the gs_libusb-master/examples directory: Really, you can put the ROM anywhere on your Linux machine, this will just make the next command simpler.
  • Execute the loader to run an NES emulator and your ROM: Run the following command from the root gs_libusb-master directory. It will load Neon64 and and whatever ROM you specify in place of YOUR_ROM.bin!
sudo ./gsuploader/gsuploader examples/neon64gs.bin examples/YOUR_ROM.bin
  • Let everything load: Here, all you have to do is wait. Your N64 will appear to freeze while the load is happening; that’s okay. Once the load is complete, you should see the Neon64 main screen. Hit any button and play! At any time, you can hit L+R to bring up the main menu.

Step 5: Run other programs

  • The examples folder contains a simple demo program that you can run, too. With everything set up and working, just run the following command to load it instead of neon64gs.bin:
sudo ./gsuploader/gsuploader examples/flames.bin
  • It’s also possible to build and run your own programs to be compatible with this load method. To do so, you’ll need to install gsdevkit, which will give you a complete GameShark-compatible homebrew toolchain. Go knock yourself out!

Much of the info in this tutorial was gleaned from the relevant GitHub Readme files and the following video. Have a look if you want to see someone walk through running the loader:

Running Homebrew on the N64 Without an Everdrive

Sega Saturn Homebrew with Game BASIC

Sega Saturn for Game BASIC - Complete in Box
Game BASIC for Sega Saturn – Complete in Box

Part 1: Introduction


Game BASIC for Sega Saturn is a homebrew development kit that allows you to program games for the Sega Saturn using the BASIC programming language.  If you’re familiar with the PlayStation’s Net Yaroze platform, think of this as the Saturn’s answer to it – just cheaper and easier to get started with.

Game BASIC’s use of the BASIC language makes for a very low barrier to entry in terms of programming skill.  Though the Saturn is notoriously difficult to program for, Game BASIC makes it easy to get started and is surprisingly powerful, allowing very easy sprite manipulation and straightforward 3D polygon implementation.  It even includes an adapter cable that allows you to communicate with the Saturn from your PC to transfer or save programs and streamline development. For example, here’s a Pilotwings-esque demo, but in Game BASIC:

“Jump” demo, provided with Game BASIC (video courtesy Satakore.com)

The caveat?  Game BASIC was released only in Japan, so this means a complete setup can be difficult to obtain and all documentation is in Japanese!  Moreover, the supporting software that allows you to use your PC for streamlined development was intended for the Windows 95 era and flat out does not install on modern systems. Oh, and the adapter cable that allows you to connect your Saturn to your PC is a 25-pin serial connection!

Who in the world still has both Game BASIC and a Windows 95 PC with a physical serial port? Nobody!  (Well, unless you’re Modern Vintage Gamer) But if you’re a brave experimenter who’s not afraid to tinker a bit, there are still multiple options to get everything working, even today!  You can even do a lot just via emulation.  So, let’s head to the Lab and get started…

Continue reading “Sega Saturn Homebrew with Game BASIC”