NOTE: Please download the source code from the latest release, not by downloading the .zip of the code directly as I have not yet figured out why my setup is working despite having made the same changes to the repo I forked this from.
Read the wiki for build instructions: https://github.com/Zoltar007/target_osx/wiki
- 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.
- Install prerequisites (Ubuntu):
sudo apt install -y git build-essential pkg-config libusb-1.0-0-dev libsdl2-dev
. - Clone the repo:
git clone https://github.com/sm64-port/sm64-port.git
. - Place a Super Mario 64 ROM called
baserom.<VERSION>.z64
into the project folder for asset extraction, whereVERSION
can beus
,jp
, oreu
. - Run
make
to build. Qualify the version throughmake VERSION=<VERSION>
. Add-j4
to improve build speed (hardware dependent based on the amount of CPU cores available). - The executable binary will be located at
build/<VERSION>_pc/sm64.<VERSION>.f3dex2e
.
- Install and update MSYS2, following all the directions listed on https://www.msys2.org/.
- 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
.
- 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 toMy Documents
by enteringcd /c/Users/<username>/Documents
. - Clone the repo:
git clone https://github.com/sm64-port/sm64-port.git
, which will create a directorysm64-port
and then enter itcd sm64-port
. - Place a Super Mario 64 ROM called
baserom.<VERSION>.z64
into the project folder for asset extraction, whereVERSION
can beus
,jp
, oreu
. - Run
make
to build. Qualify the version throughmake VERSION=<VERSION>
. Add-j4
to improve build speed (hardware dependent based on the amount of CPU cores available). - The executable binary will be located at
build/<VERSION>_pc/sm64.<VERSION>.f3dex2e.exe
inside the project directory.
- If you get
make: gcc: command not found
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". - If you get
Failed to open baserom.us.z64!
you failed to place the baserom in the project folder. You can writels
to list the files in the current working directory. If you are in thesm64-port
directory, make sure you see it here. - 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 withsm64-port
. Usecd <dir>
to enter the correct directory. If you writels
you should see all the project files, includingMakefile
if everything is correct. - If you get any error, be sure MSYS2 packages are up to date by executing
pacman -Syu
andpacman -Su
. - When you execute
gcc -v
, be sure you seeTarget: i686-w64-mingw32
orTarget: x86_64-w64-mingw32
. If you seeTarget: x86_64-pc-msys
, you either opened the wrong MSYS start menu entry or installed the incorrect gcc package.
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.
- Install prerequisites:
sudo apt install -y build-essential git binutils-mips-linux-gnu python3
. - Clone the repo from within Linux:
git clone https://github.com/n64decomp/sm64.git
. - Place a Super Mario 64 ROM called
baserom.<VERSION>.z64
into the project folder for asset extraction, whereVERSION
can beus
,jp
, oreu
. - Run
make
to build. Qualify the version throughmake TARGET_N64=1 VERSION=<VERSION>
. Add-j4
to improve build speed (hardware dependent based on the amount of CPU cores available).
Ensure the repo path length does not exceed 255 characters. Long path names result in build errors.
Install WSL and a distro of your choice following Windows Subsystem for Linux Installation Guide for Windows 10. We recommend either Debian or Ubuntu 18.04 Linux distributions under WSL. Note: WSL1 does not currently support Ubuntu 20.04.
Next, clone the SM64 repo from within the Linux shell:
git clone https://github.com/n64decomp/sm64.git
Then continue following the directions in the Linux installation section below.
There are 3 steps to set up a working build.
The build system has the following package requirements:
binutils-mips
python3 >= 3.6
qemu-irix
(When building without GCC)
Dependency installation instructions for common Linux distros are provided below:
To install build dependencies:
sudo apt install -y build-essential git binutils-mips-linux-gnu python3
Download latest package from qemu-irix Releases.
Install this package with:
sudo dpkg -i qemu-irix-2.11.0-2169-g32ab296eef_amd64.deb
To install build dependencies:
sudo pacman -S base-devel python
Install the following AUR packages:
- mips64-elf-binutils (AUR)
- qemu-irix-git (AUR)
Most modern Linux distributions should have equivalent packages to the other two listed above. You may have to use a different version of GNU binutils. Listed below are fully compatible binutils distributions with support in the makefile, and examples of distros that offer them:
mips64-elf-
(Arch AUR)mips-linux-gnu-
(Ubuntu and other Debian-based distros)mips64-linux-gnu-
(RHEL/CentOS/Fedora)
You may also use Docker to handle installing an image with minimal dependencies.
For each version (jp/us/eu) for which you want to build a ROM, put an existing ROM at
./baserom.<VERSION>.z64
for asset extraction.
Run make
to build the ROM (defaults to VERSION=us
).
Other examples:
make VERSION=jp -j4 # build (J) version instead with 4 jobs
make VERSION=eu COMPARE=0 # build (EU) version but do not compare ROM hashes
Resulting artifacts can be found in the build
directory.
The full list of configurable variables are listed below, with the default being the first listed:
-
VERSION
:us
,jp
,eu
,sh
(WIP) -
GRUCODE
:f3d_old
,f3d_new
,f3dex
,f3dex2
,f3dzex
-
COMPARE
:1
(compare ROM hash),0
(do not compare ROM hash) -
NON_MATCHING
: Use functionally equivalent C implementations for non-matchings. Also will avoid instances of undefined behavior. -
CROSS
: Cross-compiler tool prefix (Example:mips64-elf-
). -
QEMU_IRIX
: Path to aqemu-irix
binary. -
TARGET_N64
:0
If set to one, will build an N64 ROM. An unmodified repository will produce one of the following ROMs depending on whatVERSION
is set to:- sm64.jp.z64
sha1: 8a20a5c83d6ceb0f0506cfc9fa20d8f438cafe51
- sm64.us.z64
sha1: 9bef1128717f958171a4afac3ed78ee2bb4e86ce
- sm64.eu.z64
sha1: 4ac5721683d0e0b6bbb561b58a71740845dceea9
- sm64.jp.z64
Installing Docker is the recommended avenue for macOS users. This project does not support macOS natively due to lack of macOS host support.
Create the docker image with docker build -t sm64
.
To build, mount the local filesystem into the Docker container and build the ROM with docker run
.
docker run --rm --mount type=bind,source="$(pwd)",destination=/sm64 sm64 make VERSION=us -j4
For a Linux host, Docker needs to be instructed which user should own the output files:
docker run --rm --mount type=bind,source="$(pwd)",destination=/sm64 --user $UID:$UID sm64 make VERSION=us -j4
Resulting artifacts can be found in the build
directory.
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
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