Play D2R Mobile on iPhone, iPad or Mac: the complete guide

For iPhone or iPad, use an Apple silicon Mac with Xcode if you have one. For playing on that Mac, build the native Mac app instead. Both start from your own purchased Switch game files and end in local, offline play. There is no Battle.net multiplayer or access to online characters.

This guide follows D2R Mobile v1.0.15, commit b94670c795e28742abe1a9cadd64a234a77260ab, checked on 15 October 2026. SwitchToAny inspected the release, documentation and build scripts. We did not build the game, install these packages, run a device test or test save recovery. Expected results below are checkpoints for your attempt, not results we observed. Author-reported runs and unverified steps are identified separately.

1. Choose a route before downloading

Your goal and computer	Start here	What you will make
iPhone / iPad, with an Apple silicon Mac and Xcode	Shared Mac preparation, then iOS build and install	A signed DmIOS.app, installed directly by the project script
Play on an Apple silicon Mac	Shared Mac preparation, then native Mac	A locally signed Mac app tied to its build workspace
iPhone / iPad, with Windows, Linux or a Mac without Xcode	Experimental shell route	An output.ipa that still needs signing and installation
No computer, Intel Mac for native play, or online multiplayer required	Stop here	This guide establishes no suitable route

No route here provides the game or keys. The repository and release shells contain tools and host code; the files generated from your game are for your own use and must not be redistributed. Use only files you are entitled to obtain and use; ownership is not a universal exemption from local rules. Game-file policy and exact inputs

Check chip and memory together

• Minimum chip: A14 / M1. A13 and earlier, including the A12Z 2020 iPad Pro, are unsupported because the graphics layer needs Metal 3.
• 4 GB RAM devices are unsupported, including A14 models. A qualifying chip does not override this limit.
• A14 with at least 6 GB RAM: no player reports in the pinned device table. Treat this as experimental, not confirmed compatibility.
• A15–A16 devices with sufficient memory: need a Legacy Device Pack. The author cites player runs on iPhone 14 Pro Max (A16, 6 GB) and iPhone 13 Pro Max (A15, 6 GB); that does not certify every model.
• A17 Pro and later, and M-series iPads: use native BC textures. Apple silicon Macs do not need the Legacy Device Pack.
• Free-account signing on 6 / 8 GB devices remains unverified. The author reports that signing route on a 12 GB device; it removes memory-related entitlements as well as iCloud sync.

These are separate gates: chip, RAM, OS, texture path and signing. A positive answer to one does not clear the others. Device table · Free-account limits

Choose the build for your operating system

Destination OS	Source-build switch	Shell route
iOS / iPadOS 26+	Default	D2RMobile-shell-build-input.zip
iOS / iPadOS 18–25	DM_IOS_M3=1	D2RMobile-shell-ios18-build-input.zip
macOS 26+	Default Mac build	Use the native Mac route
macOS 15–25	DM_MAC_M3=1	Use the native Mac route

Earlier systems are outside this guide. An older-API build and a Legacy Device Pack solve different problems and may both be needed. For example, an A16 phone on iOS 18 needs both. The M3 switch means the older graphics API here; it does not require an M3 processor. System-build guide

Allow enough storage and time

Upstream lists about 8.4 GB for the extracted RomFS, about 20 GB free for package extraction, and roughly 12 GB of working space for shell packaging. These describe different stages, not one total requirement. Keep headroom for originals, generated files and backups. A Legacy Device Pack adds roughly 3 GB of preparation space. On the phone, the 18 required archives total about 5.6 GB, plus the app, shader cache, saves and roughly 1 GB for the Legacy Device Pack when needed. There is no verified all-in minimum-free-space figure. Inputs · Packaging · Texture pack

2. Prepare the exact game inputs

You need your purchased Switch Diablo II: Resurrected, Reign of the Warlock expansion and update 1.0.34.0. The tools call this version 3.3.94012. A PC installation, the base game without the expansion, or another Switch update is not a substitute.

The upstream game-file guide explains exporting the Update ExeFS and RomFS from your own console. This guide starts with those lawfully obtained files. Do not download a stranger’s ROM, keys, resource pack or ready-made game-containing IPA.

For the Mac routes, arrange the files like this. ~/dm-work is the default generated-data workspace, separate from the source checkout:

~/dm-work/data/switch/3.3.94012/Update/
├── ExeFS/
│   ├── main
│   ├── sdk
│   └── subsdk0
└── RomFS/
    └── data/
        ├── build_manifest.psv
        └── … .data archives from your own Update dump

Keep the full prepared RomFS on the computer for generation. The phone needs only the 18 archives listed later in this guide; the smaller phone set is not the complete build input.

If your own dump is instead a combined .xci or .nsp containing the base and correct update, upstream provides an extraction path using hactool. First get the source with the clone commands in section 3, then return here. After obtaining/building hactool from its official repository and putting it on your PATH, run from the D2R Mobile source root:

dm/tools/extract_game.sh "/path/to/your-game.xci" "/path/to/your-own/prod.keys"

Replace both example paths; .nsp is also accepted. The script writes the workspace layout above and checks the version. Keys stay on your computer. Never upload them or include them in a help request. The author reports its own .xci run and community .nsp reports; we have not reproduced either. If the version check fails, return to the matching owned inputs rather than bypassing the check. Extraction and input validation

3. Prepare the Mac once

This section serves both iOS and native Mac builds. If you are using the shell route, go to section 6 instead.

Get the matching source

In Terminal, choose a directory for source code, then run:

git clone --branch v1.0.15 --single-branch \
  https://github.com/jhaizhou-ops/d2r-mobile.git d2r-mobile-v1.0.15
cd d2r-mobile-v1.0.15
git rev-parse HEAD

Checkpoint: the last line must be b94670c795e28742abe1a9cadd64a234a77260ab. A detached-HEAD notice is normal for a release tag. The source root is the directory containing setup.sh, dm/ and docs/. Do not mix a newer source checkout with this guide’s shell. Pinned source

Install the build tools and run the read-only check

Install Xcode from Apple, open it once and complete its setup. The author’s recorded toolchain is Xcode 26.6, XcodeGen 2.45.4, .NET SDK 10.0, SPIRV-Cross 1.4.357, and Python 3.14. These are recorded versions, not a claim that every newer toolchain works. A Mac running an older OS still needs a usable Xcode/toolchain; an older target does not guarantee the build tools run on that Mac. Building the older Mac app on macOS 15 has no hands-on verification upstream. Dependencies · Mac limitations

If you use Homebrew, the upstream dependency commands are:

brew install xcodegen dotnet spirv-cross python
xcodebuild -version
xcrun -sdk iphoneos metal --version
./setup.sh check

Checkpoint: the check finds the tools, validates main, sdk and subsdk0, finds build_manifest.psv and all 18 required archives, and reports All checks passed. Missing signing details are a non-blocking note at this preparation stage. Follow the first missing-item instruction, then run the check again. Check implementation

If Xcode is installed but the command points elsewhere, the check recommends sudo xcode-select -s /Applications/Xcode.app for an Xcode installed there. If the Metal compiler is missing, it recommends xcodebuild -downloadComponent MetalToolchain. Use the actual Xcode path on your Mac; do not proceed with a failed compiler check.

Generate the game-specific files

From the source root:

./setup.sh
source "$HOME/dm-work/build/cache/dm/venv/bin/activate"

The first command prepares Python packages, rewrites the game code and builds the shader libraries. The second activates the environment needed by the later scripts. If you chose a different DM_ROOT, use that same workspace consistently instead of ~/dm-work.

Checkpoint: setup finishes with 工作区就绪 (“workspace ready”) and the next build commands, without a failed step. “Some files were generated” is not a pass. For a .NET startup error, check dotnet --list-runtimes and the setup diagnostic; v1.0.15 tries to discover the runtime itself. For a shader failure, fix the reported dependency and rerun setup. Do not remove all caches or change version checks indiscriminately. The script can resume completed work. Setup source

Setup changes three generated fingerprint files in the source tree: dmsh_chain.lock, dmsh_chain.h and c1_full.tsv. That is expected; keep those local changes out of contributions. At this point, choose iOS or native Mac. Build overview

4. Build, sign and install on iPhone or iPad

4A. Configure signing and connect the device

1. Sign in to your own Apple account in Xcode’s Settings → Accounts / Apple Accounts. Choose the team you intend to use. A paid developer team can use the supported entitlements; a free Personal Team requires the free-account switch below.
2. Connect the iPhone or iPad by cable, unlock it and complete Apple’s pairing/trust prompts. For development-signed apps, follow Apple’s Developer Mode instructions, including the device restart and confirmation. Developer Mode reduces device security; enable it only if you accept that trade-off. Pairing may be needed before the setting appears.
3. Run xcrun devicectl list devices. Keep the Identifier for this device as DM_DEVICE. Separately, get its hardware UDID from Xcode’s device details (Devices and Simulators / Device Hub) for DM_IOS_UDID. These are different identifiers.
4. From the source root, make the local configuration once:

cp dm/ios/local.env.example dm/ios/local.env

Edit dm/ios/local.env in a text editor. Do not copy over an existing configuration during updates. Fill the existing entries; the following shows their purpose, not values to paste unchanged:

DM_TEAM_ID=your_team_id
DM_BUNDLE_ID=your.unique.d2rmobile
DM_DEVICE=the_devicectl_identifier
DM_IOS_UDID=the_hardware_udid
DM_FREE_ACCOUNT=1

Set DM_FREE_ACCOUNT=1 only for a free Personal Team; leave it empty for a paid team. Use your own unique reverse-domain bundle ID and keep it stable for future installs. Leave MINI_SSH empty. Free-account builds must target the connected, unlocked phone with DM_IOS_UDID set so automatic signing can create its provisioning profile. Local configuration · Apple’s device-signing workflow

Free-account cost: re-sign/reinstall every seven days; no iCloud save sync; no increased-memory, sustained-execution or extended-virtual-addressing entitlements. The author’s reported free-account gameplay was on 12 GB hardware; 6 / 8 GB is unverified. An otherwise supported phone may therefore still hit a memory limit with this signing route. Signing limits

4B. Add the Legacy Device Pack if your chip needs it

Skip this subsection for A17 Pro-and-later / M-series devices. Eligible A14–A16 devices need both a locally generated texture pack and an app built with that exact pack. Unsupported A13 / 4 GB devices do not become supported by adding it.

From the source root, with the setup Python environment active, build Arm’s encoder at the documented version:

brew install cmake
git clone --branch 5.2.0 --depth 1 \
  https://github.com/ARM-software/astc-encoder.git astc-encoder
cmake -S astc-encoder -B astc-encoder/b \
  -DASTCENC_ISA_NEON=ON -DCMAKE_BUILD_TYPE=Release
cmake --build astc-encoder/b -j
export ASTCENC="$PWD/astc-encoder/b/Source/astcenc-neon"

R="$HOME/dm-work/data/switch/3.3.94012/Update/RomFS"
D="$HOME/dm-work/out/legacy_pack"
python3 dm/tools/astc_pack.py "$R" "$D/work" --preset thorough
python3 dm/tools/casc_overlay.py pack "$R" "$D/pack" "$D/work/repl.tsv" 0-8
python3 dm/tools/astc_pack.py finalize "$D/pack"

Checkpoint: $D/pack contains pack.json and a Legacy Device Pack folder containing manifest.json and data/00-00000008.data. If a generation step fails, stop there. Keep the same pack for the build and the phone; regenerating it requires rebuilding the app. Upstream texture-pack procedure · Arm encoder release

4C. Build the selected combination

From the source root, enter dm/ios and run one matching build command. The free/paid choice comes from your local.env:

cd dm/ios

# iOS 26+, native BC textures
./run.sh build

# iOS 18–25, native BC textures
DM_IOS_M3=1 ./run.sh build

# iOS 26+, Legacy Device Pack
DM_ASTC_PACK="$HOME/dm-work/out/legacy_pack/pack" ./run.sh build

# iOS 18–25, Legacy Device Pack
DM_IOS_M3=1 DM_ASTC_PACK="$HOME/dm-work/out/legacy_pack/pack" ./run.sh build

Checkpoint: the script reports 构建完成 (“build complete”), and the default output is:

~/dm-work/run/ios/dd/Build/Products/Release-iphoneos/DmIOS.app

build compiles and signs but does not install. A failure is recorded in ~/dm-work/run/ios/build.log. For “no devices from which to generate a provisioning profile,” recheck the connected unlocked phone, free-team switch and hardware UDID. For entitlement errors, check whether you mistakenly built paid-account capabilities with a Personal Team. Keep the actual error; do not randomly remove capabilities. Build script · Older systems

4D. Install the built app

Still in dm/ios, with the phone connected:

./run.sh install

Checkpoint: the script reports 装机完成 (“installation complete”) and the app appears on the device. If it fails, inspect ~/dm-work/run/ios/install.log, DM_DEVICE, pairing, device lock state and available storage. Installation does not prove the game can start.

For a free account, trust your developer identity under Settings → General → VPN & Device Management before the first launch, as the pinned project instructions require. If the icon is blocked, check that trust and Developer Mode before changing game files. Open the app normally; a missing-resources screen is expected until section 7. Install and configuration instructions

5. Build and open the native Mac app

After shared preparation, run one of these from the source root, inside the setup Python environment:

# macOS 26+
dm/tools/mac_app.sh

# macOS 15–25
DM_MAC_M3=1 dm/tools/mac_app.sh

Checkpoint: look in ~/dm-work/out/macapp/ for D2R Mobile.app or D2R Mobile M3.app, respectively. The older-API build also produces its own shader libraries there. These apps use local ad-hoc signing: no developer account and no device registration.

Double-click the matching app. In the resource picker, choose:

~/dm-work/data/switch/3.3.94012/Update/RomFS

That folder contains data/. If the app rejects it, check the directory and complete game inputs, then choose again. No Legacy Device Pack is needed on an Apple silicon Mac.

Keep the workspace and output directory where they are. The small .app points to generated game code, overlays and shaders in those locations. Moving the app to another Mac or deleting ~/dm-work does not produce a portable installation. Native Mac build and launch

Mac controls for your first character

The documented interface follows the Switch controller layout, with keyboard prompts:

Action	Key or input
Move	W A S D; arrow keys navigate directional selections
Confirm / back	Space or J / Esc or K
Menu / new character	=
Enter game / context-dependent confirm	Return
Map	Tab
Other controller buttons	U / I = X / Y; Q / E = L / R; Z / C = ZL / ZR; F / G = stick presses
Full screen / quit	Control-Command-F / Command-Q

Create a character: = → choose a class with arrows → Return → confirm the mode with Return or Space → Return to edit the name → type and Return → Return again to create. Then select the character and enter the game. Start with a disposable non-hardcore character until saving is checked.

The mouse can select menu items, walk on empty ground, attack a monster with the main attack, interact with objects, and double-click or drag inventory items. Right-click means back, not the PC game’s second skill. A connected gamepad switches the prompts when a button is pressed. For language, use Options → Custom → language → Accept All, then restart.

Evidence boundary: upstream’s key, mouse, quit and gamepad checks are largely unattended simulations; it explicitly has not completed hands-on checks of the keyboard, physical gamepad or resource picker. Click-to-walk was checked in camp, not all terrain. A player run on Mac mini M4 / macOS 15.7 used an app built elsewhere. These controls are a documented procedure to try, not a hands-on review from this site. Full controls and limitations

6. Without Xcode: prepare an IPA, then resolve signing

This is the experimental alternative. The author reports Windows 11 / Python 3.12 packaging, followed by signing on a Mac and iPhone gameplay. Fresh Windows dependency installation, Linux packaging, and signing/installing with tools such as AltStore or Sideloadly remain unverified. Do not read “Windows packaging works” as a verified Windows-only route. If you need a verified end-to-end recipe for your particular sideloading tool, stop at this boundary. Exact report

Choose the official build input

Download and extract Source code (zip) from v1.0.15, or use the same release-tag clone shown in section 3. Then get one matching shell:

• iOS 26+: D2RMobile-shell-build-input.zip
• iOS 18–25: D2RMobile-shell-ios18-build-input.zip
• Optional download verification: same-release SHA256SUMS.txt

A shell ZIP is not a final IPA. Do not rename it and install it. It lacks the game program, generated overlay and shaders. The packer fills those from your own files. Same-release source and shell are required even though the rewriter generation still says r44. Release packaging rules

Prepare the packer’s dependencies

The upstream list requires Python 3.9+, pillow numpy lz4 capstone unicorn, clang, the .NET SDK and SPIRV-Cross 1.4.357.0, not an arbitrary current SPIRV-Cross build. Use the official Python, LLVM, .NET and SPIRV-Cross sources. The tool checks missing dependencies at startup. A separate Python virtual environment is sensible; inside it:

python -m pip install pillow numpy lz4 capstone unicorn

Use python3 instead if that is your Python 3 command. On Windows, upstream builds the pinned SPIRV-Cross with Git, CMake, Ninja and LLVM:

git clone --branch vulkan-sdk-1.4.357.0 --depth 1 https://github.com/KhronosGroup/SPIRV-Cross
cmake -S SPIRV-Cross -B SPIRV-Cross/build -G Ninja -DCMAKE_BUILD_TYPE=Release -DCMAKE_CXX_COMPILER=clang++ -DSPIRV_CROSS_ENABLE_TESTS=OFF
cmake --build SPIRV-Cross/build --target spirv-cross

Add the directory containing the resulting spirv-cross.exe to your command search path. Dependency installation from a clean Windows machine was not tested upstream; if one of these commands fails, resolve that tool before attempting the packer. Packer dependencies

Make your own install package

From the matching D2R source root, with the required tools available:

python dm/tools/d2rm_pack.py "/path/to/D2RMobile-shell-build-input.zip" "/path/to/Update" "/path/to/output.ipa"

Replace paths with your local paths, using the iOS 18 shell when appropriate. The middle directory must directly contain ExeFS/ and RomFS/. On macOS/Linux, use python3 if needed.

For eligible older chips, get the encoder for your computer from Arm’s official release. Windows x64 can use its supplied astcenc-avx2.exe. Run these three commands from the D2R source root, replacing every quoted path with a real local path (use Windows paths in PowerShell):

python dm/tools/astc_pack.py "/path/to/Update/RomFS" "/path/to/legacy/work" --astcenc "/path/to/astcenc" --preset thorough
python dm/tools/casc_overlay.py pack "/path/to/Update/RomFS" "/path/to/legacy/pack" "/path/to/legacy/work/repl.tsv" 0-8
python dm/tools/astc_pack.py finalize "/path/to/legacy/pack"

Before running the packer, set D2RM_ASTC_PACK to the full path of the resulting pack directory. In PowerShell this is $env:D2RM_ASTC_PACK = 'C:\path\to\legacy\pack'; in a Mac/Linux shell it is export D2RM_ASTC_PACK="/path/to/legacy/pack". Note the extra M: source builds use DM_ASTC_PACK, while the packer uses D2RM_ASTC_PACK. Check for pack.json and the complete Legacy Device Pack subfolder before packaging.

Checkpoint: the packer finishes its content checks and writes your output.ipa (upstream estimates about 130 MB), with an older-device-support message if that option was included. A shader digest mismatch means the pinned shader toolchain or source/shell pairing needs attention; do not disable the comparison. Missing dm/derived.tsv or game-program files means packaging is incomplete. The resulting IPA contains game content and is not a file to share. Packaging procedure

Signing and first launch

Only the generated IPA is input to signing. Upstream describes using a sideloading tool with your own Apple account, but explicitly has not verified that step. Follow the chosen tool’s official instructions and limits; this guide makes no promise that it preserves the necessary entitlements. Do not send credentials to a stranger or install someone else’s profile as a shortcut. Free signing still needs renewal and does not provide iCloud saves.

After a successful install, continue to resource import. Packages made without Apple’s shader compiler also show a one-time shader-preparation screen. The author measured roughly seven minutes on one iPhone 17 Pro Max, not a universal time estimate. Keep the phone cool and let the progress finish; revisiting may recount cached work. OS updates, reinstalling or cache removal can trigger it again. A full Xcode build, or a packer run with Apple’s compiler available, precompiles those libraries and has no such first-launch step. Shader preparation and signing caveat

7. Put the 18 resource archives on iPhone or iPad

The installed app does not include the large game resource archives. From your own RomFS/data, put these 18 files into one folder, for example Game Resources:

00-00000001.data  00-00000002.data  00-00000003.data
00-00000004.data  00-00000005.data  00-00000006.data
01-00000001.data  01-00000002.data
02-00000001.data  02-00000002.data
03-00000001.data  03-00000002.data
04-00000001.data  04-00000002.data
05-00000001.data  05-00000002.data
17-00000001.data  17-00000002.data

Use one of these methods:

1. Finder on a Mac: connect and unlock the device → select it in Finder → Files → drag the folder onto D2R Mobile.
2. Files on the device: copy that folder into On My iPhone / On My iPad → D2R Mobile. It must be inside this app’s folder, not merely sitting in Downloads or iCloud Drive.

If using a Legacy Device Pack, also copy the whole Legacy Device Pack folder beside Game Resources. Keep its manifest.json and data subfolder intact. The pack supplements the 18 archives; it does not replace them.

Return to the app and tap Retry. Checkpoint: all 18 archives pass the app’s presence/size checks and the resource screen clears. If it lists missing files, complete that copy and retry. If it rejects an archive size, recopy the correct source file rather than renaming another file. You do not need to put prod.keys, ExeFS or the build manifest on the phone. Exact archive list and copying · Validation logic and alternate USB command

8. Make your first session a play-and-save check

Once the main menu appears, create a new non-hardcore test character before importing valued progress. On touch devices, use New Character, choose a class and mode, enter a name with the system keyboard and confirm. On Mac, use the key sequence above. D2R Mobile includes its own optional modes and convenience features; review Options → Custom rather than assuming every default matches the unmodified game.

Learn only the controls you need first

• Touch: move with the left virtual stick. Tapping empty ground does not move your character in the pinned touch implementation; the Mac’s mouse click-to-walk is separate. Press a skill to cast, hold to repeat and drag a skill button to aim. Tap NPCs/items to interact; tap an item to inspect it, double-tap to equip/use and drag to move it.
• Controller: connect through the device’s normal controller pairing, then press a button for controller prompts. Touch the screen to return to touch controls. Follow the prompts; the mapping follows the Switch layout.
• Mac: use W A S D, the displayed skill keys, or the documented mouse interactions. Right-click is back. Start with camp interactions before relying on complex terrain or a physical controller, where the upstream hands-on evidence is limited.

These are documented controls, not observations from a SwitchToAny session. The overview README describes tapping ground to move, but the pinned touch implementation and world-input source explicitly reserve empty-ground movement for the Mac mouse; follow the stick instruction on iOS. Controller reference · Mac reference

Check the entire loop

1. Enter camp. Confirm that you can move, hear sound, open and close inventory, and use an equipped skill or interact with an NPC.
2. Make a small, recognizable change on this test character, such as a changed inventory arrangement. Note what you expect to persist.
3. Use the game’s save-and-exit action to return to character selection. Let it finish before closing the app.
4. After save-and-exit has finished and character selection is back, close the app fully: on iOS remove it from the app switcher; on Mac use Command-Q. Launch it again from its icon, select the same character and re-enter. Merely switching away and resuming does not check a fresh launch. Never close it during a save or loading transition.
5. Confirm that the character and expected progress are still present. Only then begin a longer session or consider importing a copied save.

This is a proposed acceptance check for your device, not a completed site test. Record build → install → menu → in-game → save → reopen separately. A main-menu screenshot proves less than this full loop, and a short loop does not prove long-session stability.

v1.0.15’s author reports a fix for saving when switching away while paused. The Mac quit path waits up to three seconds for saving and logs if it exits without a completed save. Do not treat background saving as a backup or use forced termination as your normal exit. If your test loses progress, stop using valuable saves and collect the log. Save fix · Mac quit behavior

9. Back up, update and renew the signature

Know where your saves live

Installation	Save folder
iPhone / iPad	Files → On My iPhone / iPad → D2R Mobile → save
Default native Mac app	~/Library/Application Support/D2R Mobile/save
Older-API native Mac app	~/Library/Application Support/D2R Mobile M3/save

Back up the entire save folder after quitting the game. It includes character folders, shared-stash files, Settings and the project’s added progression. A lone .d2s is not a complete backup. Custom-page switches are device-local and are not all carried by this folder. Save layout

On iOS, copy the whole folder with Files or Finder to a separate location you control, ideally on the Mac as well. A second folder inside the same app container does not protect you from uninstalling that app. On Mac, duplicate save into a dated backup directory outside the live save path. Open the backup and check that it contains the character folders and other files, not an empty folder or an extra save/save/ layer. Keep the original unchanged until you have verified the copy.

Before any update or free-account renewal

1. Finish a normal save-and-exit, quit, and make that separate backup.
2. Keep your source version, bundle ID, signing team, OS branch and texture-pack choice recorded.
3. Xcode route: obtain the source for the new release, rerun ./setup.sh, activate its Python environment, then rebuild with your same signing configuration and required switches. Install with ./run.sh install.
4. Shell route: get the new release’s source and matching shell, then rerun d2rm_pack.py. Re-sign the newly generated IPA. An unchanged r44 label does not mean the old shell contains new app fixes.
5. Native Mac: rerun setup and the matching mac_app.sh command. Preserve the workspace; the default and M3 apps have separate save locations.
6. Open the updated app and repeat the character/progress/reopen check. Keep the backup until you are satisfied the update works.

For a free account, renew by rebuilding/re-signing and installing over the existing app with the same identity before the seven-day signature expires. Do not start by uninstalling. Upstream expects an in-place installation to retain resources and saves, but this site has not tested every signing tool’s behavior. If your tool demands deletion, stop and verify your independent backup first. If the signature has already expired, preserve any accessible save data before experimenting. Renewal constraints · Release update rules

The original 18 archives do not change with every app release and normally remain in place. A regenerated Legacy Device Pack does require the matching app build. Keeping the same bundle ID is important, but it is not a substitute for a backup.

Optional save import and rollback

For an iPhone-to-Mac import, upstream documents a manual copy of the whole save folder. Quit both games, back up both originals, rename the destination’s existing save to a dated backup, then put the copied folder directly in the destination app’s support directory. The result must be …/D2R Mobile/save/<character folders>, not …/save/save/…. Use the D2R Mobile M3 directory for that app. Launch and check characters and progress.

If the import fails, quit again, move the imported copy aside and restore the untouched destination backup under the name save. Do not merge folders blindly or overwrite the only original. Leave adjacent save.work / save.new temporary folders alone; upstream says the app rebuilds them.

Evidence boundary: the author reports one unattended Mac run loading a prepared save. Actual phone-to-Mac copying through Files, the reverse direction and hardcore characters have not had a complete hands-on verification. A copied save also creates two independent histories, not ongoing sync. Do not try this first with your only valued character. Import procedure and limits

iCloud is optional and narrower: the iOS route needs paid developer signing and the iCloud entitlement; free-account builds and locally built Mac apps have no iCloud save sync. Preserved conflicting shared-stash copies are not automatically merged back into the game. Keep an independent backup even when sync is enabled. Signing · Conflict behavior in v1.0.13

10. If you get stuck, return to the failed stage

Symptom	First check and next step
Setup says the game version differs	Confirm Switch 1.0.34.0 with the expansion, all three ExeFS files and complete RomFS. Stop rather than bypassing the version check.
Shader translation or .NET startup fails	Use setup’s exact dependency diagnostic. Check the runtime and compiler first; shell packaging specifically requires the pinned SPIRV-Cross. A later file existing does not prove translation completed.
Build fails on provisioning	Check the account/team, DM_FREE_ACCOUNT, connected unlocked phone and hardware DM_IOS_UDID; read build.log.
Install fails or app cannot open	Check install.log, the devicectl DM_DEVICE, device pairing, Developer Mode, developer trust and signature validity.
“This Package Is Not Ready”	You installed a shell or an incomplete/mixed-release package. Repackage with matching v1.0.15 source and shell, then sign/install the output IPA.
“This Device Is Not Supported”	Check chip and RAM. A13/A12Z cannot gain Metal 3 through a pack or re-sign. 4 GB devices remain unsupported.
“One More Step for This Device”	The app lacks the Legacy Device Pack build support. Rebuild with DM_ASTC_PACK, or repack with D2RM_ASTC_PACK.
“Supplementary Pack Required” or pack mismatch	Copy the complete matching Legacy Device Pack folder beside the resources. Check its manifest, archive and build pairing.
Missing-resource screen	Copy all 18 correct archives into the app’s folder; complete or recopy the named files and tap Retry.
Mac app fails after cleanup / moving files	Restore its original workspace/output paths or rebuild from intact inputs. The .app alone is not portable.
Save or character is missing	Stop writing new progress. Check default versus M3 save location, bundle identity and accidental save/save nesting. Work from copies and preserve the backup.

These are source-backed checks, not guaranteed fixes for every cause. On iOS, use the pause menu’s Share diagnostic log; on Mac, Help → Share Log…. Mac logs are in ~/Library/Logs/D2R Mobile/ or D2R Mobile M3/. For a pre-launch iOS failure, boot.txt and boot.previous.txt may be visible in the app’s Files folder. iOS logging · Mac logging · Release self-checks

When asking upstream for help, include exact model/RAM, OS, v1.0.15 commit, build route, signing type, texture-pack choice, the last successful checkpoint and the exact error. Inspect logs for private information before sharing. Never attach game archives, keys, Apple credentials or your only save.

What this guide establishes

• Source-verified: matching assets, build switches, paths, input checks, controls as documented, and the source behavior cited above.
• Author-reported: public-shell packaging, automated Mac checks, limited device/player runs, and specific release fixes under their stated conditions.
• Still unverified here: every build, installation, controller interaction, performance claim and save-recovery sequence. We ran none of the game binaries.

You now have a complete sequence with a stopping point for each failed stage. For project changes and the separate evidence behind broader claims, see D2R Mobile status. For the architecture, see why ARM64 is not enough.