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.

sm64ps.png


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

    Code: 
    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

    Code: 
    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

    Code: 
    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​
 
Last edited:
Click to expand...
pinky
yeah, the source code to mario 64 was leaked among a bunch of other nintendo stuff. I've confirmed the save from the wii u version works with the normal vc mario 64 (just name change). it also works with project 64. save is exact same length in bytes, so you should be able to use any save with any version of this port. just on the wii u, leave out the save state file with saviine or else your old saves will revert back when you load the game.

edit: I'm mostly referring to this where it saves aren't compatible (but they are): https://gbatemp.net/download/super-mario-64-wii-u-port-100-save-file.36590/
 
tthousand
The source code used to help create this port was actually made/de-compiled/reverse-engineered before the leak. The only thing leak related about this port may or may not be the Luigi model.

As far as the save file goes, that is pretty interesting stuff you shared there. Nice to know if you made progress on one of your home systems, you can now take that progress on the road with your to-go console.
 
pinky
tthousand said:
The source code used to help create this port was actually made/de-compiled/reverse-engineered before the leak. The only thing leak related about this port may or may not be the Luigi model.

As far as the save file goes, that is pretty interesting stuff you shared there. Nice to know if you made progress on one of your home systems, you can now take that progress on the road with your to-go console.
Click to expand...

I learned what I know about saves from @Berion who's said that most saves should work regardless of console. you just need to know how to handle any security or headers/footers/padding. I've been messing with wii u saves a lot lately. I got nds saves working from wii u to ds to wii u. unlike n64 saves, those require trimming substantially, but it's easy.
 
zeroofall
pinky said:
I learned what I know about saves from @Berion who's said that most saves should work regardless of console. you just need to know how to handle any security or headers/footers/padding. I've been messing with wii u saves a lot lately. I got nds saves working from wii u to ds to wii u. unlike n64 saves, those require trimming substantially, but it's easy.
Click to expand...

You should take what you know and see if you can turn it into a conversion application or write a outline of the differences so others can learn from it. Would be neat to have a universal nintendo save tool for all those old saves to live on in new consoles.
 
ShaloooGT
Can I use the save from the VC Wii version??

Also, legally speaking, does it count as "legally obtained" if I purchased that version of the game??
 
tthousand
Roxanne said:
That's not possible and will never be probably.
Click to expand...

Yeah, I had just looked it up a month ago and could not find anything. When @GREEDY PESOS said something, for a second I thought maybe I missed something, but I just don't see how that would be possible without an emualotor or port. Too bad the "whatever they call their streaming" doesn't go both ways. While it's nice to be able to play PS3 games streamed to your Vita, it would be awesome if it went the other way around too.
 
arcadekidflo
Can something be done about right stick camera ? It's somehow reversed . I saw some people on Youtube correcting it in the rom . Also, since devs have the source code , can they change the text popups so the buttons are ported to Playstation style ? For example displaying " Press O " instead of " Press B "

PS : I hope for a Conker port someday :)
 
E
I have compiled the PS3 port myself for the last commit, still have a lot of graphic glitches and not full screen - will come back to this later
 
zeroofall
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?
 
E
You will need to switch to the "ps3" branch, just type "git checkout ps3" inside the directory you just cloned.
The default build is a elf file, I manually convert it into a pkg, approximately 6MB (US version)
 
T
hi! I made the proccess for the PS3 and got the final file, but what I have to do now? how can I run this file on ps3?
 
tthousand
You need to install the PKG, meaning your PS3 must either be on CFW or HEN (at least I assume you can install PKGs on HEN, but I do not really know anything about HEN myself). Either that, or run it on your PC using RPCS3 emulator.
 
You must log in or register to reply here.

Similar threads

Featured content

Trending content

Latest posts

Back
Top