PS VITA / PS TV [UPDATE 2] Super Mario 64 Ported to Vita, PSP, PS2, PS3 and PS4!

Yes, you read right... Super Mario 64 has been ported to the Vita, PSP, PS2, PS3 and PS4 (not to be confused with emulated)! You will need to build your own copy of the game using your own legitimately obtained N64 Rom. Do NOT ask for links or pre-complied copies on this site, or you will be banned. And definitely do NOT link to any pre-complied copies!

Super Mario 64 is arguably one of the greatest video games of all time, and certainly one of the most significant releases of it's time. Personally, I remember having my parents drop me off at Toys 'R' Us for hours at a time, just so that I could sample a little of this incredible 3D platformer on the demo-kiosk before it was officially released to the public. I will never forget when Babbage's called me three days prior to the release of the Nintendo 64, and said I could come pick up my console and copy of Super Mario 64 that day. I spent countless hours mastering the controls, obtaining all 120 stars, and just enjoying the beautifully created worlds.

Fast forward 24 years later, and the game is still getting lots of attention; both from Nintendo with the rumored release of Super Mario 64 for the Nintendo Switch (which I will definitely be purchasing day one, and seeing if I can jump to top of the castle with 0 stars), and also from the underground scene communities. As many of you probably already know, developers have been hard at work reverse engineering the game to create a de-complied source code, which led to the recent release of the PC port of Super Mario 64. And now thanks to the advancements of the various PlayStation scenes, we now have a ports playable on PS Vita, PS TV, PSP, PS2, PS3 and PS4.

You might ask yourself, "Why would I care about a port of a game I can already play through an emulator?" Well, for starters, being a port there is a much more room for upgrades and modifications. For example, there has already been a release of Super Luigi 64 to the Vita, which replaces Mario with a developer created Luigi model as well as changes the text in various scenes, so you can now enjoy the whole game as the other brother. And this is just the beginning... who knows what else we will see in the future.

As for other ports coming soon, we will have to wait and see what time brings us. Now there is a port playable on every PlayStation console with the exception of the PS1. There is just no telling where this game will pop up next. We have already seen the game popping up on MS-DOS, Andriod, Dreamcast and even Xbox.

WARNING:
Do NOT post links to any pre-compiled GAMES, or you will be banned from this site.
Do NOT ask for links to any pre-compiled GAMES, or you will be banned from this site.
We are sharing this news as it is an incredible story, but we do not tolerate piracy on our site.
You have been warned...​

Video Gameplay Vita Information PSP Information PS2 Information PS3 Information PS4 Information

• 
  PlayStation 2 Port on PCSX2 Emulator
  
  
  PlayStation 3 Port on RPCS3 Emulator
  
  
  PSP Port on PPSSPP Emulator
  
• 
  Super Mario 64 Port
  
  
  • This repo contains a full decompilation of Super Mario 64 (J), (U), and (E) with minor exceptions in the audio subsystem.
  • Naming and documentation of the source code and data structures are in progress.
  • Efforts to decompile the Shindou ROM steadily advance toward a matching build.
  • Beyond Nintendo 64, it can also target the PS Vita.
  
  This repo does not include all assets necessary for compiling the game. A prior copy of the game is required to extract the assets.
  
  
  
  Building for the Vita
  
  Savedata is stored at ux0:data/sm64_save_file.bin. cont.m64 can be put either into the same folder, or into ux0:app/SM6400001/ for TAS input.
  
  
  
  Prerequisites
  
  For running this on the PS Vita you will first need to extract the runtime shader compiler. Follow this guide for help with that.
  
  • Ubuntu: sudo apt install -y git build-essential pkg-config.
  • Windows (x86_64): pacman -S git make python3 mingw-w64-x86_64-gcc
  
  
  
  Build Instructions
  
  
  1. Install VitaSDK
  2. Clone the repo: git clone https://github.com/bythos14/sm64-vita.git, which will create a directory sm64-vita and then enter it cd sm64-vita.
  3. Place a Super Mario 64 ROM called baserom.<VERSION>.z64 into the repository's root directory for asset extraction, where VERSION can be us, jp, or eu.
  4. Building
     1. Run ./build_deps.sh to build and install dependencies. This only has to be done once.
     2. Run make TARGET_VITA=1 vpk to build the game. Add -j4 to improve build time.
  5. The installable vpk will be located at build/us_vita/sm64.<VERSION>.f3dex2e.vpk
  
  
  
  Known Issues
  
  
  1. At the start of the game with Princess Peach, when the camera zooms out the skybox seems to disappear. It is only temporary.
  2. The fade transition from the star select menu seems to have a minor bug, the white background disappears as it fades into white.
  3. TAS Input stops working if the app is suspended or the Vita is put to sleep.
  
  
  
  Contributing
  
  If you want to make it better, fork it and make it better. Thanks.
  
  
  
  Credits
  
  
  • WOLFwang for making the livearea assets.
  • fgsfds for the initial effort towards porting to the vita.
  • The original sm64decomp team for this impressive decompilation.
  • The sm64-port team for the work towards porting the decomp to other platforms.
  • Rinnegatamante for making the vitaGL library, it made this port alot easier.
• 
  PSP Port of PC
  
  PSP Project Discord: https://discord.gg/5w4B69
  
  
  
  Super Mario 64 Port
  
  
  • This repo contains a full decompilation of Super Mario 64 (J), (U), and (E) with minor exceptions in the audio subsystem.
  • Naming and documentation of the source code and data structures are in progress.
  • Efforts to decompile the Shindou ROM steadily advance toward a matching build.
  • Beyond Nintendo 64, it can also target Linux and Windows natively.
  This repo does not include all assets necessary for compiling the game. A prior copy of the game is required to extract the assets.
  
  
  
  Building native executables
  
  
  
  
  Linux
  
  
  1. Install prerequisites (Ubuntu): sudo apt install -y git build-essential pkg-config libusb-1.0-0-dev libsdl2-dev.
  2. Clone the repo: git clone https://github.com/sm64-port/sm64-port.git, which will create a directory sm64-port and then enter it cd sm64-port.
  3. Place a Super Mario 64 ROM called baserom.<VERSION>.z64 into the repository's root directory for asset extraction, where VERSION can be us, jp, or eu.
  4. Run make to build. Qualify the version through make VERSION=<VERSION>. Add -j4 to improve build speed (hardware dependent based on the amount of CPU cores available).
  5. The executable binary will be located at build/<VERSION>_pc/sm64.<VERSION>.f3dex2e.
  
  
  
  Windows
  
  
  1. Install and update MSYS2, following all the directions listed on https://www.msys2.org/.
  2. From the start menu, launch MSYS2 MinGW and install required packages depending on your machine (do NOT launch "MSYS2 MSYS"):
  • 64-bit: Launch "MSYS2 MinGW 64-bit" and install: pacman -S git make python3 mingw-w64-x86_64-gcc
  • 32-bit (will also work on 64-bit machines): Launch "MSYS2 MinGW 32-bit" and install: pacman -S git make python3 mingw-w64-i686-gcc
  • Do NOT by mistake install the package called simply gcc.
  1. The MSYS2 terminal has a current working directory that initially is C:\msys64\home\<username> (home directory). At the prompt, you will see the current working directory in yellow. ~ is an alias for the home directory. You can change the current working directory to My Documents by entering cd /c/Users/<username>/Documents.
  2. Clone the repo: git clone https://github.com/sm64-port/sm64-port.git, which will create a directory sm64-port and then enter it cd sm64-port.
  3. Place a Super Mario 64 ROM called baserom.<VERSION>.z64 into the repository's root directory for asset extraction, where VERSION can be us, jp, or eu.
  4. Run make to build. Qualify the version through make VERSION=<VERSION>. Add -j4 to improve build speed (hardware dependent based on the amount of CPU cores available).
  5. The executable binary will be located at build/<VERSION>_pc/sm64.<VERSION>.f3dex2e.exe inside the repository.
  PSP
  
  Notes:Currently only supported building under linux and WSL There is a file in the psp/ folder called snd_eng.prx
  
  • This file is used to accelerate the sound generation and increase performance.
  • It belongs next to the EBOOT.PBP or PRX.
  1. Install the PSP toolchain https://github.com/pspdev/psptoolchain.
  2. Place a Super Mario 64 ROM called baserom.<VERSION>.z64 into the repository's root directory for asset extraction, where VERSION can be us, jp, or eu.
  3. Run make TARGET_PSP=1
  4. Optionally if you would prefer an EBOOT.PBP for use on CFW Run make TARGET_PSP=1 pbp , and the folder mario64 will be made in the build folder.
  Windows Possible Guide: NOTE UNSUPPORTED currently
  
  1. Install the PSP toolchain https://darksectordds.github.io/html/MinimalistPSPSDK/index.html
  2. Install Python3 from python.org, NOT the Windows Store
  3. Download this pack of helpful tools http://www.mediafire.com/file/jogmmqfwclmji3v/file
  4. Add the full path of where you installed the pspsdk eg. C:\pspsdk\bin to your environment variables
  5. Copy the files from pspsdk_bin/ from the windows pack into the bin folder where you installed the pspsdk. The same folder you used above.
  6. Copy python3.exe from the windows pack, next to makefile and baserom
  7. Make a folder called tmp, next to makefile and baserom
  8. Place a Super Mario 64 ROM called baserom.<VERSION>.z64 into the repository's root directory for asset extraction, where VERSION can be us, jp, or eu.
  9. Copy files in tools/ from the windows pack to tools folder in source, next to makefile and baserom
  10. Open Powershell in the sm64 folder and run this:
  11. Run make -t -s -C .\tools\ and ignore the line about make: /bin/sh: Command not found
  12. Go back to powershell window:
  13. Run $PSDefaultParameterValues['*:Encoding'] = 'utf8' Only needed if using Powershell, if using cmd.exe you can skip this.
  14. Run make TARGET_PSP=1 SHELL=sh PYTHON=py
  15. Optionally if you would prefer an EBOOT.PBP for use on CFW Run make TARGET_PSP=1 SHELL=sh PYTHON=py pbp, and the folder mario64 will be made in the build folder.
  
  
  
  Troubleshooting
  
  
  1. If you get make: gcc: command not found or make: gcc: No such file or directory although the packages did successfully install, you probably launched the wrong MSYS2. Read the instructions again. The terminal prompt should contain "MINGW32" or "MINGW64" in purple text, and NOT "MSYS".
  2. If you get Failed to open baserom.us.z64! you failed to place the baserom in the repository. You can write ls to list the files in the current working directory. If you are in the sm64-port directory, make sure you see it here.
  3. If you get make: *** No targets specified and no makefile found. Stop., you are not in the correct directory. Make sure the yellow text in the terminal ends with sm64-port. Use cd <dir> to enter the correct directory. If you write ls you should see all the project files, including Makefile if everything is correct.
  4. If you get any error, be sure MSYS2 packages are up to date by executing pacman -Syu and pacman -Su. If the MSYS2 window closes immediately after opening it, restart your computer.
  5. When you execute gcc -v, be sure you see Target: i686-w64-mingw32 or Target: x86_64-w64-mingw32. If you see Target: x86_64-pc-msys, you either opened the wrong MSYS start menu entry or installed the incorrect gcc package.
  
  
  
  Debugging
  
  The code can be debugged using gdb. On Linux install the gdb package and execute gdb <executable>. On MSYS2 install by executing pacman -S winpty gdb and execute winpty gdb <executable>. The winpty program makes sure the keyboard works correctly in the terminal. Also consider changing the -mwindows compile flag to -mconsole to be able to see stdout/stderr as well as be able to press Ctrl+C to interrupt the program. In the Makefile, make sure you compile the sources using -g rather than -O2 to include debugging symbols. See any online tutorial for how to use gdb.
  
  
  
  ROM building
  
  It is possible to build N64 ROMs as well with this repository. See https://github.com/n64decomp/sm64 for instructions.
  
  
  
  Project Structure
  
  

  sm64 ├── actors: object behaviors, geo layout, and display lists ├── asm: handwritten assembly code, rom header │ └── non_matchings: asm for non-matching sections ├── assets: animation and demo data │ ├── anims: animation data │ └── demos: demo data ├── bin: C files for ordering display lists and textures ├── build: output directory ├── data: behavior scripts, misc. data ├── doxygen: documentation infrastructure ├── enhancements: example source modifications ├── include: header files ├── levels: level scripts, geo layout, and display lists ├── lib: SDK library code ├── rsp: audio and Fast3D RSP assembly code ├── sound: sequences, sound samples, and sound banks ├── src: C source code for game │ ├── audio: audio code │ ├── buffers: stacks, heaps, and task buffers │ ├── engine: script processing engines and utils │ ├── game: behaviors and rest of game source │ ├── goddard: Mario intro screen │ ├── menu: title screen and file, act, and debug level selection menus │ └── pc: port code, audio and video renderer ├── text: dialog, level names, act names ├── textures: skybox and generic texture data └── tools: build tools

  
  
  
  Contributing
  
  Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.
  Run clang-format on your code to ensure it meets the project's coding standards.
  Official Discord: https://discord.gg/7bcNTPK
  
• 
  Super Mario 64 Port
  
  
  • This repo contains a full decompilation of Super Mario 64 (J), (U), and (E) with minor exceptions in the audio subsystem.
  • Naming and documentation of the source code and data structures are in progress.
  • Efforts to decompile the Shindou ROM steadily advance toward a matching build.
  • Beyond Nintendo 64, it can also target Linux and Windows natively.
  This repo does not include all assets necessary for compiling the game. A prior copy of the game is required to extract the assets.
  
  
  
  Building PS2 executables
  
  
  
  
  Using Docker
  
  
  1. Ensure Git and Docker are installed on your system.
  2. Check out repo, submodules, etc:
  git clone https://github.com/fgsfdsfgs/sm64-port.git -b ps2 --recursive cd sm64-port
  
  1. Copy in your baserom.XX.z64: cp /path/to/baserom.us.z64 .
  2. Build Docker image: docker build . -t sm64_ps2
  3. Compile using your Docker image: docker run --rm -ti -v $(pwd):/sm64 sm64_ps2 make --jobs 4
  
  
  
  Manually under Linux (WSL not tested, MSYS2 probably won't work)
  
  
  1. Ensure Git, GCC, GNU Make and Python 3 are installed on your system:
  # for example on Ubuntu sudo apt install git build-essential python3
  
  1. Ensure PS2SDK and GSKit are installed on your system and the environmental variables PS2SDK and GSKIT are defined and PS2SDK is in your PATH. You can follow the installation instructions in the ps2dev repo, or you can get the latest stable binaries and use them:
  wget https://github.com/ps2dev/ps2dev/releases/download/v1.1/ps2dev-ubuntu-latest.tar.gz tar xvzf ps2dev-ubuntu-latest.tar.gz export PATH="$(pwd)/ps2dev/ee/bin:$(pwd)/ps2dev/iop/bin:$(pwd)/sm64-port/tools:${PATH}" export PS2SDK=$(pwd)/ps2dev/ps2sdk export GSKIT=$(pwd)/ps2dev/gsKit
  
  1. Check out repo, submodules, etc:
  git clone https://github.com/fgsfdsfgs/sm64-port.git -b ps2 --recursive cd sm64-port
  
  1. Copy in your baserom.XX.z64: cp /path/to/baserom.us.z64 .
  2. Compile: make -j4
  In both cases, the resulting ELF will be in build/<region>_ps2/.
  
  
  
  (Optional) Strip and pack resulting ELF:
  
  ee-strip --strip-all build/us_ps2/sm64.us.f3dex2e.elf ps2-packer build/us_ps2/sm64.us.f3dex2e.elf build/us_ps2/sm64.packed.elf
  Remember that packed ELFs will take a while to unpack before starting.
  
  
  
  Building native executables
  
  
  
  
  Linux
  
  
  1. Install prerequisites (Ubuntu): sudo apt install -y git build-essential pkg-config libusb-1.0-0-dev libsdl2-dev.
  2. Clone the repo: git clone https://github.com/sm64-port/sm64-port.git, which will create a directory sm64-port and then enter it cd sm64-port.
  3. Place a Super Mario 64 ROM called baserom.<VERSION>.z64 into the repository's root directory for asset extraction, where VERSION can be us, jp, or eu.
  4. Run make to build. Qualify the version through make VERSION=<VERSION>. Add -j4 to improve build speed (hardware dependent based on the amount of CPU cores available).
  5. The executable binary will be located at build/<VERSION>_pc/sm64.<VERSION>.f3dex2e.
  
  
  
  Windows
  
  
  1. Install and update MSYS2, following all the directions listed on https://www.msys2.org/.
  2. From the start menu, launch MSYS2 MinGW and install required packages depending on your machine (do NOT launch "MSYS2 MSYS"):
  • 64-bit: Launch "MSYS2 MinGW 64-bit" and install: pacman -S git make python3 mingw-w64-x86_64-gcc
  • 32-bit (will also work on 64-bit machines): Launch "MSYS2 MinGW 32-bit" and install: pacman -S git make python3 mingw-w64-i686-gcc
  • Do NOT by mistake install the package called simply gcc.
  1. The MSYS2 terminal has a current working directory that initially is C:\msys64\home\<username> (home directory). At the prompt, you will see the current working directory in yellow. ~ is an alias for the home directory. You can change the current working directory to My Documents by entering cd /c/Users/<username>/Documents.
  2. Clone the repo: git clone https://github.com/sm64-port/sm64-port.git, which will create a directory sm64-port and then enter it cd sm64-port.
  3. Place a Super Mario 64 ROM called baserom.<VERSION>.z64 into the repository's root directory for asset extraction, where VERSION can be us, jp, or eu.
  4. Run make to build. Qualify the version through make VERSION=<VERSION>. Add -j4 to improve build speed (hardware dependent based on the amount of CPU cores available).
  5. The executable binary will be located at build/<VERSION>_pc/sm64.<VERSION>.f3dex2e.exe inside the repository.
  Troubleshooting
  
  
  1. If you get make: gcc: command not found or make: gcc: No such file or directory although the packages did successfully install, you probably launched the wrong MSYS2. Read the instructions again. The terminal prompt should contain "MINGW32" or "MINGW64" in purple text, and NOT "MSYS".
  2. If you get Failed to open baserom.us.z64! you failed to place the baserom in the repository. You can write ls to list the files in the current working directory. If you are in the sm64-port directory, make sure you see it here.
  3. If you get make: *** No targets specified and no makefile found. Stop., you are not in the correct directory. Make sure the yellow text in the terminal ends with sm64-port. Use cd <dir> to enter the correct directory. If you write ls you should see all the project files, including Makefile if everything is correct.
  4. If you get any error, be sure MSYS2 packages are up to date by executing pacman -Syu and pacman -Su. If the MSYS2 window closes immediately after opening it, restart your computer.
  5. When you execute gcc -v, be sure you see Target: i686-w64-mingw32 or Target: x86_64-w64-mingw32. If you see Target: x86_64-pc-msys, you either opened the wrong MSYS start menu entry or installed the incorrect gcc package.
  
  
  
  Debugging
  
  The code can be debugged using gdb. On Linux install the gdb package and execute gdb <executable>. On MSYS2 install by executing pacman -S winpty gdb and execute winpty gdb <executable>. The winpty program makes sure the keyboard works correctly in the terminal. Also consider changing the -mwindows compile flag to -mconsole to be able to see stdout/stderr as well as be able to press Ctrl+C to interrupt the program. In the Makefile, make sure you compile the sources using -g rather than -O2 to include debugging symbols. See any online tutorial for how to use gdb.
  
  
  
  ROM building
  
  It is possible to build N64 ROMs as well with this repository. See https://github.com/n64decomp/sm64 for instructions.
  
  
  
  Project Structure
  
  

  sm64 ├── actors: object behaviors, geo layout, and display lists ├── asm: handwritten assembly code, rom header │ └── non_matchings: asm for non-matching sections ├── assets: animation and demo data │ ├── anims: animation data │ └── demos: demo data ├── bin: C files for ordering display lists and textures ├── build: output directory ├── data: behavior scripts, misc. data ├── doxygen: documentation infrastructure ├── enhancements: example source modifications ├── include: header files ├── levels: level scripts, geo layout, and display lists ├── lib: SDK library code ├── rsp: audio and Fast3D RSP assembly code ├── sound: sequences, sound samples, and sound banks ├── src: C source code for game │ ├── audio: audio code │ ├── buffers: stacks, heaps, and task buffers │ ├── engine: script processing engines and utils │ ├── game: behaviors and rest of game source │ ├── goddard: Mario intro screen │ ├── menu: title screen and file, act, and debug level selection menus │ └── pc: port code, audio and video renderer ├── text: dialog, level names, act names ├── textures: skybox and generic texture data └── tools: build tools

  
  
  
  Contributing
  
  Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.
  Run clang-format on your code to ensure it meets the project's coding standards.
  Official Discord: https://discord.gg/7bcNTPK
  
• 
  Super Mario 64 Port
  
  
  • This repo contains a full decompilation of Super Mario 64 (J), (U), and (E) with minor exceptions in the audio subsystem.
  • Naming and documentation of the source code and data structures are in progress.
  • Efforts to decompile the Shindou ROM steadily advance toward a matching build.
  • Beyond Nintendo 64, it can also target Linux and Windows natively.
  This repo does not include all assets necessary for compiling the game. A prior copy of the game is required to extract the assets.
  
  
  
  Building native executables
  
  
  
  
  Linux
  
  
  1. Install prerequisites (Ubuntu): sudo apt install -y git build-essential pkg-config libusb-1.0-0-dev libsdl2-dev.
  2. Clone the repo: git clone https://github.com/sm64-port/sm64-port.git, which will create a directory sm64-port and then enter it cd sm64-port.
  3. Place a Super Mario 64 ROM called baserom.<VERSION>.z64 into the repository's root directory for asset extraction, where VERSION can be us, jp, or eu.
  4. Run make to build. Qualify the version through make VERSION=<VERSION>. Add -j4 to improve build speed (hardware dependent based on the amount of CPU cores available).
  5. The executable binary will be located at build/<VERSION>_pc/sm64.<VERSION>.f3dex2e.
  
  
  
  Windows
  
  
  1. Install and update MSYS2, following all the directions listed on https://www.msys2.org/.
  2. From the start menu, launch MSYS2 MinGW and install required packages depending on your machine (do NOT launch "MSYS2 MSYS"):
  • 64-bit: Launch "MSYS2 MinGW 64-bit" and install: pacman -S git make python3 mingw-w64-x86_64-gcc
  • 32-bit (will also work on 64-bit machines): Launch "MSYS2 MinGW 32-bit" and install: pacman -S git make python3 mingw-w64-i686-gcc
  • Do NOT by mistake install the package called simply gcc.
  1. The MSYS2 terminal has a current working directory that initially is C:\msys64\home\<username> (home directory). At the prompt, you will see the current working directory in yellow. ~ is an alias for the home directory. You can change the current working directory to My Documents by entering cd /c/Users/<username>/Documents.
  2. Clone the repo: git clone https://github.com/sm64-port/sm64-port.git, which will create a directory sm64-port and then enter it cd sm64-port.
  3. Place a Super Mario 64 ROM called baserom.<VERSION>.z64 into the repository's root directory for asset extraction, where VERSION can be us, jp, or eu.
  4. Run make to build. Qualify the version through make VERSION=<VERSION>. Add -j4 to improve build speed (hardware dependent based on the amount of CPU cores available).
  5. The executable binary will be located at build/<VERSION>_pc/sm64.<VERSION>.f3dex2e.exe inside the repository.
  Troubleshooting
  
  
  1. If you get make: gcc: command not found or make: gcc: No such file or directory although the packages did successfully install, you probably launched the wrong MSYS2. Read the instructions again. The terminal prompt should contain "MINGW32" or "MINGW64" in purple text, and NOT "MSYS".
  2. If you get Failed to open baserom.us.z64! you failed to place the baserom in the repository. You can write ls to list the files in the current working directory. If you are in the sm64-port directory, make sure you see it here.
  3. If you get make: *** No targets specified and no makefile found. Stop., you are not in the correct directory. Make sure the yellow text in the terminal ends with sm64-port. Use cd <dir> to enter the correct directory. If you write ls you should see all the project files, including Makefile if everything is correct.
  4. If you get any error, be sure MSYS2 packages are up to date by executing pacman -Syu and pacman -Su. If the MSYS2 window closes immediately after opening it, restart your computer.
  5. When you execute gcc -v, be sure you see Target: i686-w64-mingw32 or Target: x86_64-w64-mingw32. If you see Target: x86_64-pc-msys, you either opened the wrong MSYS start menu entry or installed the incorrect gcc package.
  
  
  
  Debugging
  
  The code can be debugged using gdb. On Linux install the gdb package and execute gdb <executable>. On MSYS2 install by executing pacman -S winpty gdb and execute winpty gdb <executable>. The winpty program makes sure the keyboard works correctly in the terminal. Also consider changing the -mwindows compile flag to -mconsole to be able to see stdout/stderr as well as be able to press Ctrl+C to interrupt the program. In the Makefile, make sure you compile the sources using -g rather than -O2 to include debugging symbols. See any online tutorial for how to use gdb.
  
  
  
  ROM building
  
  It is possible to build N64 ROMs as well with this repository. See https://github.com/n64decomp/sm64 for instructions.
  
  
  
  Project Structure
  
  

  sm64 ├── actors: object behaviors, geo layout, and display lists ├── asm: handwritten assembly code, rom header │ └── non_matchings: asm for non-matching sections ├── assets: animation and demo data │ ├── anims: animation data │ └── demos: demo data ├── bin: C files for ordering display lists and textures ├── build: output directory ├── data: behavior scripts, misc. data ├── doxygen: documentation infrastructure ├── enhancements: example source modifications ├── include: header files ├── levels: level scripts, geo layout, and display lists ├── lib: SDK library code ├── rsp: audio and Fast3D RSP assembly code ├── sound: sequences, sound samples, and sound banks ├── src: C source code for game │ ├── audio: audio code │ ├── buffers: stacks, heaps, and task buffers │ ├── engine: script processing engines and utils │ ├── game: behaviors and rest of game source │ ├── goddard: Mario intro screen │ ├── menu: title screen and file, act, and debug level selection menus │ └── pc: port code, audio and video renderer ├── text: dialog, level names, act names ├── textures: skybox and generic texture data └── tools: build tools

  
  
  
  Contributing
  
  Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.
  Run clang-format on your code to ensure it meets the project's coding standards.
  Official Discord: https://discord.gg/7bcNTPK
  
• 
  Super Mario 64 Port
  
  
  • This repo contains a full decompilation of Super Mario 64 (J), (U), and (E) with minor exceptions in the audio subsystem.
  • Naming and documentation of the source code and data structures are in progress.
  • Efforts to decompile the Shindou ROM steadily advance toward a matching build.
  • Beyond Nintendo 64, it can also target Linux and Windows natively.
  This repo does not include all assets necessary for compiling the game. A prior copy of the game is required to extract the assets.
  
  Building for the PS4
  
  Prerequisites
  
  
  1. For running this on the PS4 you will first need to extract the OpenGL module libScePigletv2VSH.sprx and the shader compiler module libSceShaccVSH.sprx from RetroArch_PS4_r4.pkg. You can search and find this package online.
  Once extracted, transfer the modules to your PS4 in the location below. Create the subdirs if they are not there.
  /data/self/system/common/lib/libScePigletVSH.sprx
  /data/self/system/common/lib/libSceShaccVSH.sprx
  
  1. You will also need the Super Mario 64 ROM file baserom.VERSION.z64 where VERSION can be us, jp, or eu.
  
  Build Instructions
  
  
  1. Install and setup OpenOrbis-PS4-Toolchain (Version 0.5 for Linux was used at the time of this build)
  2. Clone the repo:
  git clone https://github.com/OsirizX/sm64-port.git -b ps4 --single-branch --recurse-submodules
  This will create a directory sm64-port and then enter it cd sm64-port.
  
  1. Place baserom.VERSION.z64 into the repository's root directory for asset extraction.
  2. Run make TARGET_PS4=1 pkg to build the game. Add -j4 to improve build time.
  3. The installable pkg will be located at build/UP0001-CUSA64001_00-0000000000000001.pkg
  
  Note
  
  Savedata is stored at /data/sm64_save_file.bin.
  
  Credits
  
  
  • The OpenOrbis team for their PS4 toolchain.
  • fgsfds for the PS3 port.
  • bythos14 for the Vita port.
  • flatz for making OpenGL possible on the PS4.

SOURCE:
Vita/PS TV - bythos14@GitHub
PSP - z2442@GitHub
PS2 - fgsfdsfgs@GitHub
PS3 - fgsfdsfgs@GitHub
PS4 - OsirizX@GitHub

ADDITIONAL SOURCES:
sm64-port@GitHub
n64decomp@GitHub​

 

The port is not based on any leak, but reverse engineering.

A REMAKE based on another engine, is NOT a port...
It is a remake...

The current sources are not useful for this...

An actual "port" (which includes the same engine and assets/resources) IS possible with the available sources (and already available).

interesting, if this is not based on leaked codes then could the same technique apply in other n64 games?

 

Yes, but you'd basically need a dedicated community of multiple people, who are capable of reversing a game and investing the time.

Just running/decompiling it through Ghidra will only yield Pseudo-C-code and noone would really know, what the function does... Hence Ghidra alone "won't gonna cut it".

 

I made an icon and a background for the XMB, and I found the sm64 main theme music in at3 format to play in background. I will attach here if anyone is interested.

PS: Now the file is fixed, the SND file was misptyped as SNDO instead of SND0 so the music would not play.

 

can anyone please help me converting the .exe to .pkg
i got my game as .exe now, but i would need a .pkg file.
i have no knowledge about msys2, so i am happy that i managed to compile the game.
please can anyone tell me how to get a different build?

I followed the directions and compiled a port on my own but ended up with a windows *.exe build.
What would I need to do to end up with a pkg for PS3?

did you manage to convert it somehow? i have the same issue, and after 2hors of trying, i don't seem to be able to get the game out of msys2 other than a windows.exe...
i have no knowledge about msys2 or codes...

 

I am absolutely blown away by this news. This is incredible! I was actually waiting for a n64 emulator for the ps3, but this brings it to a whole new level! This is like an actual ps2/ps3/ps4/... game!
Can we have some more information on the first post, how this actually happened? I have read that super mario 64 was actually reverse engineered to its source code structure and that a leak from nintendo has speed up the reverse engineering(?).
Also, can we have more information, if this will happen to other n64 games as well? Are there already people working on other n64 game ports? What can we expect?
Thanks,
hectorox

 

I've had my eye on this for a while, even briefly attempted to build one for my CECH-2501A, but the OP has zero info for the PS3. THE PS3 tab only lists Windows & Linux native builds...

Vita, PS2, and PS4 all list platform-specific info, but not the PS3 tab. Could someone fix or provide a link to info about building for PS3? I'd love to play this on mine... Been playing Mario games since Donkey Kong...

 

Can anyone explain the process, how self/elf files can be created/converted to a pkg file? I cannot find any good explanation and tools on the net how this should be done correctly. I would be very thankful!

 

well to build this first you to install a compiler, if you are on linux you probably have one, if you are on windows you will need to download Cygwin (Msys doesnt work for compiling Mario for me, keeps throwing Segmentation faults) and install all the required Bin's and Lib's (you can find a list on bucanero ps3toolchain page of what you will need and also install GIT and Python2 in cygwin) then install bucanero PS3Toolchain, after compiling and installing the toolchain you need to run
git clone https://github.com/fgsfdsfgs/sm64-port.git -b ps3 --recursive
after running that type
cd sm64-port
then put your ROM renamed to baserom.us.z64 (or eu or whatever region you are using) into the sm64-port folder.
then in cygwin type
make -j4
and it will take awhile but it will build a pkg for ps3.
Hopefully this helps, if not just ask and i will try and help more.

 

well to build this first you to install a compiler, if you are on linux you probably have one, if you are on windows you will need to download Cygwin (Msys doesnt work for compiling Mario for me, keeps throwing Segmentation faults) and install all the required Bin's and Lib's (you can find a list on bucanero ps3toolchain page of what you will need and also install GIT and Python2 in cygwin) then install bucanero PS3Toolchain, after compiling and installing the toolchain you need to run
git clone https://github.com/fgsfdsfgs/sm64-port.git -b ps3 --recursive
after running that type
cd sm64-port
then put your ROM renamed to baserom.us.z64 (or eu or whatever region you are using) into the sm64-port folder.
then in cygwin type
make -j4
and it will take awhile but it will build a pkg for ps3.
Hopefully this helps, if not just ask and i will try and help more.

I was actually using "Docker" for creating the build, but it only generated an elf and a self file, no pkg...
I prefer osx but I can also jump into linux, if necessary.

 

@hectorox i haven't tried with docker before (i usually just compile the source myself) i will give it a go and get back to you later, also above should work for Mac too since bucanero also has a ps3toolchain for Mac (but i dont have a Mac system to test so maybe @bucanero can give you more info on this)

 

Can we have some more information on the first post, how this actually happened? I have read that super mario 64 was actually reverse engineered to its source code structure and that a leak from nintendo has speed up the reverse engineering(?).

Naaah... AFAIR the reversal was complete and even first builds available, before the "Giga-Leaks"!

Also, can we have more information, if this will happen to other n64 games as well? Are there already people working on other n64 game ports? What can we expect?
Thanks,
hectorox

Yes multiple very known games like Zelda OOT and MM are being worked on, as well as Perfect Dark and some others.

well to build this first you to install a compiler, if you are on linux you probably have one, if you are on windows you will need to download Cygwin (Msys doesnt work for compiling Mario for me, keeps throwing Segmentation faults) and install all the required Bin's and Lib's (you can find a list on bucanero ps3toolchain page of what you will need and also install GIT and Python2 in cygwin) then install bucanero PS3Toolchain, after compiling and installing the toolchain you need to run
git clone https://github.com/fgsfdsfgs/sm64-port.git -b ps3 --recursive
after running that type
cd sm64-port
then put your ROM renamed to baserom.us.z64 (or eu or whatever region you are using) into the sm64-port folder.
then in cygwin type
make -j4
and it will take awhile but it will build a pkg for ps3.
Hopefully this helps, if not just ask and i will try and help more.

If he has Windows 10 x64, he can use WSL as well.
I recently updated the WIP WSL Tutorial with instructions to build the PS3SDK on it.

 

@hectorox i haven't tried with docker before (i usually just compile the source myself) i will give it a go and get back to you later, also above should work for Mac too since bucanero also has a ps3toolchain for Mac (but i dont have a Mac system to test so maybe @bucanero can give you more info on this)

The tool chain can be compiled in macOS, I'm using it for over a year.
You can find my notes here:
http://www.bucanero.com.ar/2019/08/14/building-your-ps3-dev-environment-on-macos/

Some minor issues might have showed up since Big Sur release, but I'm sure that they can be solved easily

I was actually using "Docker" for creating the build, but it only generated an elf and a self file, no pkg...
I prefer osx but I can also jump into linux, if necessary.

just run

make pkg

to build the final install package

 

@hectorox I just finished testing with Docker and it seems to fail to make the pkg, compiling yourself seems to be the best option using bucanero's guide on the previous post (or since you have the SELF file you could just make your own pkg, there are a few pkg builders and repackers out there)

Thanks TnA i always forget about WSL (mostly because i dont use it and just use linux on my laptop or dual boot on my main computer if i need it)

 

@hectorox I just finished testing with Docker and it seems to fail to make the pkg, compiling yourself seems to be the best option using bucanero's guide on the previous post (or since you have the SELF file you could just make your own pkg, there are a few pkg builders and repackers out there)

Thanks TnA i always forget about WSL (mostly because i dont use it and just use linux on my laptop or dual boot on my main computer if i need it)

Hi,
I managed to do it on Linux, I had to research a lot on the web to get it working. I will try to upload a step by step tutorial later on, so that everyone will be able to do that, as the documentation on github is kind of difficult and expects users to have already a lot of knowledge about it.

Update:
As promised, you can find a step by step tutorial for linux as attachment. I did not explain very much, but when you follow each step, you should end up successful.

 

Hi,
I managed to do it on Linux, I had to research a lot on the web to get it working. I will try to upload a step by step tutorial later on, so that everyone will be able to do that, as the documentation on github is kind of difficult and expects users to have already a lot of knowledge about it.

Update:
As promised, you can find a step by step tutorial for linux as attachment. I did not explain very much, but when you follow each step, you should end up successful.

Hi!!
I have a problem when I compile the build in the las step, it says me this message : "Makefile:432: *** PSL1GHT is not defined"
Does anyone know why?? Thanks a lot for the tutorial

 

Hi!!
I have a problem when I compile the build in the las step, it says me this message : "Makefile:432: *** PSL1GHT is not defined"
Does anyone know why?? Thanks a lot for the tutorial

you need to set the environment variable, e.g.

export PSL1GHT=/usr/local/ps3dev/

 

you need to set the environment variable, e.g.

export PSL1GHT=/usr/local/ps3dev/

It doesn´t work for me, do I have to use sudo to in make VERSION??
Image: https://ibb.co/zsrxJH2

 

Should it work in WSL too?

 

It doesn´t work for me, do I have to use sudo to in make VERSION??
Image: https://ibb.co/zsrxJH2

Solved

 

Hello!
I have installed this game in my vita and its all great, except game cant be saved.
What to do?