A native Apple application for the December 2000 Dinosaur Planet prototype, built directly on the work of the recompilation community.
Warning
The DinoPad base edition that PadMint builds contains Prototype Mode only. It does not contain DinoMod Enhanced or Restored Adventure because DinoMod redistribution permission has not been granted. Screenshots of Restored Adventure on this page document private development work; they are not features of the base edition.
Important
DinoPad is an Apple-platform integration of Dinosaur Planet: Recompiled, not an independent reimplementation of its work. The game-specific static recompilation and core integration come from that project. Restored Adventure uses work from DinoMod Enhanced. DinoPad's contribution is the native macOS/iOS/iPadOS application layer, Apple portability work, product experience, touch controls, lifecycle and packaging integration described below. Every upstream project retains its authorship, license, and rights boundary.
DinoPad turns the existing Dinosaur Planet static-recompilation stack into a native Apple app for Apple Silicon Mac, iPhone, and iPad. Private development builds provide two clearly separated play modes; the base edition provides Prototype Mode only. DinoPad includes a ROM-import flow, a UIKit/AppKit home screen, complete N64 touch controls, settings and diagnostics, save isolation, and Apple-specific runtime hardening. It is not an emulator, does not use JIT compilation, and does not download or execute game or mod code at runtime.
Note
AI disclosure: DinoPad uses substantial AI assistance for code, tests, documentation, debugging and maintenance. Some support replies and maintenance tasks are automated. There is no audited percentage of AI-generated code. Build, test and device records describe what was checked. This disclosure concerns DinoPad's workflow, not the authorship of its upstream projects.
Captured from Restored Adventure running natively on a physical iPad with a locally supplied copy of the game. DinoPad does not include or distribute game data.
The shortest honest description of the project is:
Dinosaur Planet: Recompiled supplies the game port; DinoMod Enhanced supplies the restoration work; N64Recomp, N64ModernRuntime, and RT64 supply the core technology; PaperPad supplied proven Apple-product patterns; DinoPad integrates and adapts that stack into the Apple applications in this repository.
| Project | What that project provides | Relationship to DinoPad |
|---|---|---|
| Dinosaur Planet: Recompiled | The base Dinosaur Planet static-recompilation project: game-specific recompiled code, runtime integration, launcher foundation, rendering integration, and mod support. | Direct foundation. DinoPad builds the pinned v0.3.0 source and carries replayable Apple patches around it. DinoPad does not claim authorship of the base recompilation. |
| DinoMod Enhanced | Community restoration work for the December 2000 prototype, including fixes for bugs and progression blockers. | Restored Adventure foundation. DinoPad statically integrates the pinned v0.9.3 restoration for constrained Apple runtimes. The restoration design and fixes remain DinoMod's work. Public redistribution is blocked pending permission or a compatible published license. |
| PaperPad | An earlier Apple static-recompilation project with native macOS, iPhone, and iPad shell patterns: setup, touch controls, lifecycle, settings, and testing. | Apple reference implementation. DinoPad adapts architectural and UX patterns to a different game and upstream stack. It does not use Paper Mario game code, art, assets, or branding. |
| N64: Recompiled | The general-purpose toolchain that statically recompiles supported N64 programs. | Core upstream technology, inherited through Dino Recompiled. DinoPad did not create the recompiler. |
| N64ModernRuntime | Shared runtime services used by modern N64 recompilation projects. | Core upstream runtime, inherited through Dino Recompiled. DinoPad maintains opt-in patches for static mods, separate profiles, restartable sessions, and mobile no-dynamic-code policy. |
| RT64 and its Plume backend | The modern renderer, including the Metal backend used on Apple hardware. | Core upstream renderer, inherited through Dino Recompiled. RT64 already supported Metal and macOS; DinoPad does not claim that work. DinoPad maintains iOS/iPadOS, UIKit, cross-build, and lifecycle patches needed by this app. |
Exact versions, commits, dependency relationships, patch order, and patch
hashes are recorded in the upstream inventory and
dependencies.lock.json. Those records are the
source of truth; names in this README are not a substitute for original
licenses or notices.
“Apple support” can mean a renderer backend, a reusable runtime, or a complete game application. Those are not equivalent. The following table describes the published documentation and checked-out source at DinoPad's exact pins; it is not a claim about every later fork or unrecorded experiment.
| Upstream at the pinned version | macOS | iOS | iPadOS |
|---|---|---|---|
| Dinosaur Planet: Recompiled v0.3.0 | No official app target was documented; upstream build instructions covered Windows and Linux. | No official app target documented. | No official app target documented. |
| DinoMod Enhanced v0.9.3 | A mod for Dino Recompiled, not a standalone app; its build prerequisites covered Windows and Linux. | No native app target documented. | No native app target documented. |
PaperPad at 644945d |
Yes. Native Apple Silicon macOS was part of the reference project. | Yes. iPhone app and Simulator/device validation were documented. | Yes. iPad app and Simulator/device validation were documented. |
| RT64 renderer | Yes. RT64 already provided Metal/macOS rendering support. | Not a complete game app; iOS was not listed as a supported application platform at the pin. | Not a complete game app; iPadOS was not listed as a supported application platform at the pin. |
Therefore, DinoPad's Apple work should not be described as inventing static recompilation, restoration, RT64, Metal rendering, or the original Apple-shell ideas. Its contribution is making this particular game stack work as a coherent macOS/iPhone/iPad product, including the mobile renderer adaptations and runtime policies that the pinned base project did not provide.
flowchart LR
NR["N64: Recompiled<br/>static recompiler"] --> DR["Dinosaur Planet: Recompiled<br/>game port and integration"]
NMR["N64ModernRuntime<br/>runtime services"] --> DR
RT["RT64 + Plume<br/>renderer and Metal backend"] --> DR
DM["DinoMod Enhanced<br/>restoration fixes"] --> DP["DinoPad<br/>Apple application and patch layer"]
DR --> DP
PP["PaperPad<br/>Apple reference patterns"] -. architecture and UX reference .-> DP
DP --> MAC["macOS"]
DP --> IOS["iPhone"]
DP --> PAD["iPad"]
DinoPad's maintained work in this repository is the integration layer around those upstreams:
- native AppKit/UIKit setup, ROM import, replacement, and private storage;
- a dinosaur-themed development launcher with Restored Adventure and warned Prototype Mode choices, plus a Prototype-only public configuration;
- complete N64 touch input, controller handoff, editable phone/tablet layouts, and a persistent in-game menu;
- Metal-window, iOS renderer, mobile sampler, cross-compilation, thread, autorelease, audio, and session-lifecycle fixes;
- static restoration dispatch with no JIT, no runtime code writes, no writable mod scanning, and no arbitrary mod installation;
- separate saves and settings for Restored and Prototype sessions;
- native settings, ROM management, diagnostics sharing, quit-to-home, and restartable in-process play sessions;
- reproducible dependency pins, a locked 28-file patch set, ROM-free package checks, smoke tests, and evidence-backed platform status.
All maintained upstream changes live as reviewable patches under
patches/. Reference checkouts under ref/ are ignored,
reproducible, and push-disabled; DinoPad does not silently rewrite upstream
history.
The private Restored build presents two isolated ways to explore the prototype:
- Restored Adventure is the recommended path. It uses the pinned DinoMod Enhanced restoration through statically linked, no-write dispatch.
- Prototype Mode is the archival path. It preserves the original incomplete experience and requires an explicit warning before launch.
The base edition exposes only Prototype Mode. In a private Restored build,
both modes keep separate saves and settings. On iPhone and iPad, DinoPad opens
with a native launcher and Files-based ROM importer, then provides touch
controls, controller handoff, a persistent ••• menu, layout editing,
settings, ROM management, diagnostics, and quit-to-home. The macOS app uses the
same mode policy with a native launcher plus keyboard and controller support.
| Target | Verified development state |
|---|---|
| macOS arm64 | Native app bundle, RT64 Metal rendering, audio, native launcher and ROM import, isolated modes/saves, controller support, desktop keyboard/mouse defaults, windowed/fullscreen switching, and clean shutdown. |
| iPhone Simulator arm64 | Native launcher/importer, complete touch shell, Restored gameplay, save-preserving relaunch, and a bounded 600-second run. |
| iPad Simulator arm64 | Tablet launcher, independent layout persistence, complete product matrix, save relaunch, and a bounded 600-second run. |
| Physical iPhone/iPad | Signed arm64 builds installed in place with private ROMs, saves, and settings preserved. Restored Adventure has been exercised on both form factors; physical-iPad controller play and reconnect are working. The 0.1.2 iPad build also passed the exact mode → Home → second-mode visual regression that previously produced a zoomed/cropped Metal surface. The full duration/audio/thermal/update matrix is still open. |
These are engineering results beyond the narrower public base build. See Status, UI parity, and the playtest matrix for the evidence behind each claim.
Note
Releases publish no app: DinoPad contains code translated from the game, so everyone makes their own base build with PadMint. See Playing DinoPad.
No Mac? Build it on a Windows PC (experimental). PadMint 0.5.27 or newer builds DinoPad for iPhone or iPad on Windows 11 (x64 or ARM64) from your own Dinosaur Planet ROM. Install Visual Studio 2022 Build Tools with Desktop development with C++, then choose DinoPad in PadMint. PadMint downloads the game-free DinoPad app from this release and adds the game code it builds from your file on your PC; nothing of yours is uploaded. The Mac build is unchanged. This Windows route is new: builds pass on Windows 11 ARM64, but a Windows-built copy has not yet been played on a device. GitHub's Mac can't build DinoPad, because that would mean uploading your game file. Details: portable module.
On an Apple Silicon Mac with Xcode and brew install cmake ninja xdelta ripgrep, download
PadMint, unzip it,
double-click PadMint.command, choose DinoPad and pick your supported
Dinosaur Planet dump. PadMint builds the DinoPad base edition from this
repository's latest release
and saves an unsigned IPA in your Downloads folder. Install it with AltStore
Classic, SideStore or Sideloadly. The IPA contains code translated from your
dump: it is yours alone; never share it.
After installation:
- Put your supported Dinosaur Planet dump in Files, iCloud Drive, or another location visible to the Apple file picker.
- Launch DinoPad and select the dump when prompted. The expected original file
is commonly named
romwith no extension. Do not selectrom_crack.z64. - DinoPad verifies and privately imports the file. A renamed, modified, or wrong-revision image is rejected.
- From DinoPad Home, choose Start Dinosaur Planet, acknowledge the archival warning, and play. The public app has no Restored Adventure selector.
The imported ROM, saves, settings, and touch layouts remain in DinoPad's private app container. Updating the same bundle in place is intended to preserve that container; deleting the app deletes its local data, so back up anything important before removing it.
The base edition cannot be converted to Restored Adventure by importing an
.nrm file. DinoPad's iOS/iPadOS port uses ahead-of-time native code and does
not permit JIT or runtime executable mod loading. DinoMod Enhanced must
therefore be compiled into a separate app and signed by the person building it.
Users who obtain DinoMod Enhanced v0.9.3 from its official project may create a private Restored build from source:
git clone https://github.com/chrissotraidis/dinopad.git
cd dinopad
# macOS host prerequisites
brew install cmake ninja xdelta
scripts/bootstrap.sh
scripts/build-tools.sh
# DinoMod's private asset-generation environment
python3 -m venv .goal-loop/dinomod-venv
.goal-loop/dinomod-venv/bin/pip install \
-r ref/dinomod-enhanced-recompiled/requirements.txt
# Use the exact original big-endian dump described below.
mkdir -p ref/DINO
cp /absolute/path/to/your/original/rom ref/DINO/rom
scripts/generate-base.sh --rom ref/DINO/rom
scripts/generate-restoration.sh
# Build native host shader tools, then the private Restored device app.
cmake -S . -B build-macos -G Ninja -DCMAKE_BUILD_TYPE=Release
cmake --build build-macos --target DinoPad
scripts/build-ios-device.sh --distribution restored \
--team YOUR10CHARTEAMID --allow-provisioning-updatesThe signed app is produced at
build-ios-device/Release-iphoneos/DinoPad.app and can be installed with Xcode
or xcrun devicectl. An unsigned private candidate can instead be built without
--team and packaged with
scripts/package-ios.sh --candidate --distribution restored; it still must be
signed before installation. Generated DinoMod code/data and a Restored IPA are
for the user's private build only and must not be redistributed without
DinoMod permission. Installing the private build over the same DinoPad bundle
is intended to preserve the existing app container, including Prototype saves
and settings; do not delete the installed app first.
DinoPad supports only the original, unmodified December 1, 2000 prototype
build. The supported dump identifies itself as DINO PLANET, game code
NDPE, revision 0, and is exactly 64 MiB (67,108,864 bytes).
The original big-endian dump used by the upstream project is conventionally
named rom with no filename extension. Some reference sets place a
modified rom_crack.z64 beside it; do not select rom_crack.z64.
DinoPad requires the original rom data and deliberately rejects that patched
emulator/flash-cart image.
To verify a copy without sharing it, calculate the MD5 of the original big-endian file. The supported fingerprint is:
49f7bb346ade39d1915c22e090ffd748
DinoPad also accepts .z64, .v64, and .n64 byte orders whose normalized
data matches that fingerprint; the filename itself is not trusted. DinoPad
normalizes and validates the selected file locally, then stores the accepted
copy only in private app storage. This project does not provide or link to
game-data downloads.
- Apple Silicon Mac running macOS 11 or later
- Xcode with macOS and iOS Simulator SDKs
- CMake 3.20+, Ninja, Git, Python 3, and
make - a MIPS-capable Clang toolchain for private generation
- at least 20 GiB of available disk space
- the supported game dump described above
Xbox-style controllers use the ordinary N64 layout: left stick moves, the south face button is A, the west face button is B, the triggers provide Z/R, the left bumper is L, the right stick provides the C buttons, and Menu is Start. iPhone and iPad additionally provide independent, editable touch layouts that disappear automatically while a controller is active. On touch screens, holding Z for half a second locks targeting until the next Z tap; Settings & Status > Hold Z to Lock Targeting can disable that behavior.
The default macOS keyboard and mouse layout is:
| N64 input | macOS default |
|---|---|
| Analog stick | W A S D |
| A / B | Left click or Space / right click or X |
| Z | Left or right Shift |
| C buttons | Q left, E right, R up, F down |
| D-pad | Arrow keys |
| L / R | Z / C |
| Start | Escape or ` |
| DinoPad settings menu | Tab |
| Fullscreen | F11 or Option+Return |
Bindings remain editable in the in-game controls screen. Existing development profiles keep their saved bindings until Reset Keyboard Bindings is used.
The unreleased base-game module preparation can build an empty iOS shell without a ROM. Its portable game module still needs validation with the supported original input before it is offered through PadMint.
Follow the complete build guide for toolchain setup, pinned dependency bootstrap, private generation, safety audits, outputs, and Simulator smoke tests.
Once the private generation prerequisites are available, the primary commands are:
scripts/build-macos-app.sh --rom /absolute/path/to/your/rom
scripts/build-ios-simulator.sh
scripts/build-ios-device.shThe macOS command creates build-macos/DinoPad.app. The iOS commands create
ROM-free local development apps for Simulator or an unsigned iphoneos
target. A personal development team may be specified for local device testing;
this is not a distribution workflow.
Never add a ROM, save, generated game code, private fixture, signing material, or local absolute path to the repository. Run the package checks in the build guide before treating any local artifact as testable.
- A full Restored start-to-credits playthrough and chapter-boundary matrix are still open.
- Controller reconnect is working on the tested physical iPad, but rumble, Bluetooth audio, thermal behavior, memory pressure, interruption handling, and the full update-preservation matrix still need broader hardware coverage.
- The archival prototype is unfinished and can contain progression blockers.
- Individual touch controls are not yet exposed as separate accessibility elements.
- The public-package configuration currently contains the original Prototype experience only. Restored Adventure remains development-only until DinoMod publishes compatible terms or grants redistribution permission.
Read Known issues and technical debt for the full evidence-linked record.
DinoPad is an Apple integration built from a pinned checkout of Dinosaur Planet: Recompiled, with a maintained patch series and a new native product shell around it. “Fork” is directionally correct, but incomplete: this repository intentionally stores adapters and replayable patches rather than a silent copy of the entire upstream tree.
The Dinosaur Planet: Recompiled contributors made the base game recompilation project. The DinoMod Enhanced contributors made the restoration fixes used by Restored Adventure. DinoPad credits and depends on both; it does not rebrand their work as its own.
No. RT64 already supported Metal and macOS. DinoPad adapts that renderer and the surrounding game/runtime stack for this specific Apple application, and carries mobile, UIKit, cross-build, and lifecycle patches needed for iPhone and iPad.
Static recompilation translates the supported N64 program into native arm64 code before the app is built. DinoPad runs that generated code with N64ModernRuntime and RT64; it does not emulate an N64 and does not generate executable code at runtime.
No. DinoPad supports exactly one December 2000 prototype and verifies the normalized input before accepting it. The ROM is never bundled, uploaded, downloaded, or shared by DinoPad.
No. Its static integration is development evidence only. DinoPad cannot publish a Restored build until DinoMod's rightsholders provide a compatible redistribution grant. The separate base build excludes all DinoMod code and data and passes the repository's compliance gate.
No. The app contains code translated from the game, so PadMint builds your own base edition from your dump on an Apple Silicon Mac. See Playing DinoPad.
| Path | Purpose |
|---|---|
apple/app/ |
Native iOS/iPadOS shell, controls, settings, diagnostics, ROM setup, and lifecycle integration. |
src/app/ |
Native macOS home and support integration. |
src/runtime/ |
DinoPad-owned runtime adapters. |
src/restoration/ |
Static restoration integration boundary. |
patches/ |
Ordered, replayable changes against exact upstream pins. |
scripts/ |
Bootstrap, build, smoke-test, runtime-guard, and package-safety automation. |
docs/ |
Architecture, implementation status, upstream inventory, rights analysis, testing, and release gates. |
docs/evidence/ |
Curated outputs that support platform and feature claims. |
Join the Discord for help and news. It is one community for DinoPad and its sibling projects, such as KartPad, BlueWake and MeleePad: ask about setup, building with PadMint, and installing, share how it runs on your device, and hear about new releases first.
Found a bug? Open an issue with your device, its OS version, and the steps that led to it.
DinoPad is independent and unofficial. It is not affiliated with or endorsed by Nintendo, Rare, Microsoft, Dinosaur Planet Recompiled, DinoMod Enhanced, PaperPad, or any of their contributors. Game names, assets, characters, copyrights, and trademarks belong to their respective owners.
Caution
DinoPad-owned work is GPL-3.0-only, but that grant does not relicense game material or third-party projects. Each upstream retains its own terms. DinoMod publishes no redistribution license, so only the build that excludes all DinoMod code and data currently passes the public-package compliance gate.
The tracked repository contains no ROM, save, extracted game asset, generated playable game source, private fixture, signing identity, or redistributable Restored package. A ROM-free executable may still contain locally generated code derived from user-supplied game data. That disclosed copyright-risk question is tracked as an advisory rather than misrepresented as an unidentified software license.
Before sharing source or a build, read:
- Rights and licensing
- Upstream sources and patch strategy
- DinoMod integration and permission boundary
- Release checklist
- Package-rights inventory
The release gate distinguishes resolved compliance requirements, non-blocking advisories, and profile-specific permission blockers. It passes for the audited base build and fails closed for Restored Adventure while DinoMod permission is absent.
DinoPad exists because of the work of many upstream communities. In addition
to the directly credited projects above, the pinned build includes work from
SDL,
RmlUi,
FreeType, and other transitive projects recorded in
dependencies.lock.json and the generated
compiled-dependency inventory.
Thank you to the Dinosaur Planet preservation, decompilation, recompilation, modding, and tooling contributors whose research and engineering made every layer of this project possible. DinoPad's documentation should always preserve that provenance: the Apple app is DinoPad's work; the foundations remain the work of their original authors.