An open-source compatibility layer for Diablo II: Resurrected with the Reign of the Warlock expansion, for iOS, macOS, Android and HarmonyOS. It brings the Nintendo Switch release you bought, expansion included, to iPhone, iPad and Mac in full: the original game code runs natively, every control is rebuilt for touch, the frame rate holds at 60 fps, and you are in a game one second after the main menu. There is now a native macOS version as well (first version): on an Apple silicon Mac it starts on double-click and works with keyboard, mouse and gamepad. Since v2.0 there is an Android version (community port): the same game program executes natively on ARM64 Android phones, with the graphics reimplemented on Vulkan; on a Snapdragon 8+ Gen 1 phone the camp and the Den of Evil and Cow Level fights all run at a median 60 fps (see "Android" below); a HarmonyOS version runs on the same engine (community port: an unsigned shell from the Releases page that you re-sign yourself, nothing to build; see "HarmonyOS"). Apple TV 4K (3rd generation, A15) has a community port (developer preview) that has reached the character-selection screen only on its author's device; see the device table below.

This is not a tech demo that "sort of runs". It is a mobile version polished for daily play, from your first character all the way through the endgame.

Platforms: iPhone / iPad (iOS 26 and later; iOS 18 – 25 with the older-API build) · Mac (Apple silicon, macOS 26 or later; macOS 15 – 25 with the older-API build) · Apple TV 4K (3rd generation, A15; community port, developer preview) · Android phones (ARM64, Android 12 or later, Vulkan 1.1; community port) · HarmonyOS phones (HarmonyOS NEXT; community port, unsigned shell from the Releases page that you re-sign yourself) · Game version: Switch release with Reign of the Warlock, 1.0.34.0 (corresponds to PC version 3.3.94012) · English / 中文 / Español / Русский / 한국어 · License: MIT · Bring your own game files

中文: README.zh-CN.md · Español: README.es.md

It is:

• The game's own aarch64 program, executing directly on the device, with no emulated CPU. iPhone and Switch use the same class of processor; only the handful of instructions that cannot run unchanged under Apple's kernel are rewritten, and every other byte of the program is left exactly as shipped. Every class, every Runeword, Terror Zones, bosses, drop rules and quest flow are identical to the original.
• The platform services the game expects — system calls, the file system, the graphics API, audio, input — provided by a small host written for Apple platforms. The graphics API is reimplemented entirely — on Metal on Apple devices, on Vulkan on Android — with no emulation layer in between, and the shaders are translated offline from the game's originals.
• A port built for phones, and taken all the way: a complete touch control scheme, edge-to-edge iPhone and true full-screen iPad display, controller support, a power saver mode, save sync, five languages (English, Chinese, Spanish, Russian and Korean), and a whole set of endgame modes and quality-of-life features the original never had.

It is not:

• An emulator, cloud gaming, or streaming.
• A source of game content. It contains none and distributes none. There is no game program, art, text, data table or shader in this repository; all of that is generated on your own machine from your own files (see docs/GAME_FILES.md). What the repository does carry is the interface information we recorded to make the port work — shader interface descriptions, the graphics API function table, addresses inside the program and the like — listed item by item in docs/DERIVED.md.
• Online. There is no multiplayer; the game runs fully offline and needs no online account.

All 44 iPhones and iPads in the closed beta — 35 devices registered for direct install (25 iPhones and 10 iPads), plus 9 TestFlight accounts with one device each — completed Normal, Nightmare and Hell with multiple characters, and the experience was excellent. From an iPhone 14 Pro Max with 6 GB of memory to the latest iPad Pro, not one device fell behind.

iPhone and iPad share a single install package.

Measured on a real device (iPhone 17 Pro Max):

_{Measurement conditions: power is whole-device power measured on 2026-10-10 on an iPhone 17 Pro Max, standing in the Act I camp at 50% brightness, with 60 fps and power saver mode measured in the same scene; battery life is calculated from the measured power and the battery capacity, not by playing from full to empty. Launch and game-entry times were measured on the same model in 2026-10; frame rate and act-change readings were taken on the same model on 2026-10-12 while moving through areas and changing acts after entering a game.}

The install package is only a little over 100 MB. The game resources (about 5.6 GB) are placed on the phone separately, and updating the app touches neither your saves nor the resources.

Why it is this fast: the program executes natively, and not a single instruction goes through emulation; graphics go straight to Metal; every shader is translated offline and compiled ahead of time, so nothing is compiled when you enter a new scene. Older chips (A16 and earlier, such as the iPhone 14 family and iPhone 15) do not support the game's original compressed texture format; they need an extra texture pack made from your own game files, and then run at full frame rate too — see docs/LEGACY_DEVICES.md.

This is not a gamepad pasted onto the screen. Every panel and every action was rebuilt for fingers under one design principle: keep the original interface language, and use gestures instead of adding buttons to the screen. Text sizes and tap targets are sized for fingers. You know how to play the moment you pick it up, and it stays comfortable over long sessions.

• Move: a virtual stick with precise diagonals; tap an NPC or the ground to path there automatically; doors, portals and cave entrances are tappable across their whole surface.
• Fight: press a skill button to cast, hold to keep casting, drag to aim at any angle; nearby monsters are targeted automatically. Two skill sets. Skills on your secondary weapons cast with one tap — the game swaps weapons, casts, and swaps back — and the button shows the charges remaining.
• Boss health bar: pinned to the top of the screen, showing the percentage remaining.
• Items: tap, double-tap, long-press and drag and drop all track your finger. Double-tap gear to equip or unequip it; drag an item anywhere onto the vendor panel to sell it; on a stack, double-tap takes 1 and long-press takes 3; long-press an empty inventory slot to sort everything.
• Text: typed with the system keyboard. Character names can be in Chinese; leave the name blank for a random one.
• Screen: on iPhone the 19.5:9 display is filled edge to edge, clear of the notch and rounded corners; on iPad the game fills the entire screen, and the interface centers itself when you open a panel; the 3D picture can be brightened.

Connect a controller and press any button: the interface switches to the original controller layout, with button prompts at the bottom of every panel. Touch the screen and you are back in the touch interface instantly. Inventory, stash, skill tree, Chronicle and settings are fully controller-navigable, with the same button mapping as on Switch. With an Xbox controller the layout switches automatically to the PC / Xbox one (bottom confirms, right goes back) and the prompts show Xbox button icons; there is nothing to turn on. With a PlayStation controller (DualSense or DualShock 4) the prompts switch to the game's own PlayStation button icons (✕ confirms, ○ goes back), contributed by @Ti800 (#119).

Finishing the original game is only the beginning. Without touching the original rules, we added a full set of endgame content that keeps you farming.

Enter through the red portal in Harrogath after completing Hell. There are 100 levels, and the monsters grow stronger with each one; fill the progress bar and slay the Rift Guardian within 15 minutes to clear a level. Every 2 levels cleared grants +1 Skill Point and +5 Stat Points, and the skill level cap rises from 20 to 40. Every 10 levels has a first-clear reward, and clearing level 10 unlocks six new equipment slots for your mercenary.

• Endgame Boss Rush: unlocks after completing Hell, with 12 stages; stage 11 is Diablo Clone, and stage 12 is the three Uber bosses.
• Elysium mode (chosen at character creation): Unique ×5, Set ×3, Runes ×5; the "no drop" chance is cut to a tenth, and bosses always drop as on a first kill.
• Kill Board: for every boss, the number of kills, the time of the first kill, how many Unique and Set items it has dropped, and your best and average kill times.

• Chronicle stash: every identified Unique and Set item has its own fixed slot, shared by all characters, searchable, with deposit and withdraw; the Deposit button sends the Unique and Set items in your inventory and Horadric Cube there in one tap.
• Stash: widened to 14 columns, with 5 personal pages and 5 shared pages.
• Trove: the gem, rune and material pages merged into one, with the Horadric Cube's crafting grid in the middle, so finding things and crafting no longer means flipping between pages. Runes, gems and materials you put into the personal or shared pages are filed here automatically.
• Pouch: an extended inventory. Runes and gems found in the field go into it automatically and take up no inventory space.

Most features can be toggled one by one in game under Options → Custom.

The whole game switches between English, Chinese, Spanish, Russian and Korean under Options → Custom; after a restart, the interface is in the language you chose. On first launch it follows your device language (Spanish from Spain uses the game's esES text, other Spanish regions use the Latin American esMX text). In English, Spanish, Russian and Korean, items, skills and monsters use the original Diablo II wording, and everything we added — Greater Rift, Chronicle, the settings page, gesture prompts, map name plates — is translated too (item notes are translated for Chinese and Spanish only). Russian is the game's single ruRU text and Korean its koKR text, with no regional variants. Voice acting: Chinese UI gets Chinese voices; Russian and Korean get the original Russian or Korean voices when your game files include them (a package built from the complete game data does), otherwise English; everything else is English. Korean was contributed by @soulsakura (#118).

flowchart LR
    G["Your game files<br/>(program + resources)"] --> P["Rewriter<br/>changes only a few instructions"]
    G --> S["Shader translation<br/>original → Metal"]
    P --> H["Host<br/>system services"]
    S --> X["Graphics layer<br/>the graphics API on Metal"]
    H --> A["iOS app<br/>touch and interface"]
    X --> A

Why you can trust it: the stability is not luck. The test and verification tooling is part of the project — unit tests for the host and graphics layers, an equivalence check for every rewritten instruction, scripted walkthrough regression for the touch interface, and on-device smoke tests. Start with make -C dm/host/tests run, make -C dm/gfx/tests run and dm/verify/regress.sh (run them inside the Python environment prepared in step 2 below; regress.sh also needs brew install llvm). How to contribute is in CONTRIBUTING.md.

Android phones use ARM64 processors just like the Switch, so, as on Apple devices, the game's own program executes directly on the phone with no CPU emulation. This release brings the whole host — system calls, file system, audio, input, saves — to Android unchanged and swaps the graphics layer for Vulkan: the NVN-to-Vulkan replay engine comes from @biglawine's HarmonyOS port, and the Android app, touch controls, Vulkan presentation and a full round of performance work, each step measured on a phone, are by @yyan160 (#113). The Apple and Android versions share the same host code, so future changes benefit both.

Measured by the port's authors on their phones (product defaults: 3D render scale capped at 0.85 and lowered dynamically when frames drop):

Minimum: ARM64, Android 12 (API 31) or later, and a GPU with Vulkan 1.1.

How to use it today: install D2RMobile-android.apk from the release page (it contains no game content). On a computer, run python3 dm/tools/d2rm_android.py <Update directory> <output directory> on your own game files to make the import pack (an android folder with the rewritten game program, every Vulkan shader bundle, the touch overlay and a few data tables), and copy it together with your game resources (the data folder) to Download/S2X/D2R Mobile/ on the phone. The App imports it with a progress screen when you open it. No adb, and no need to build the APK yourself. The full steps are in docs/ANDROID.md. The touch controls are drawn the same way as on iPhone (button sockets, silver skill silhouettes, joystick), and no virtual pad buttons cover open panels. Compared with the iOS version, a few touch details are still unfinished: the empty-skill-slot menu, the stat-point overlay, and the item image that follows your finger while dragging in a shop.

Progress, the measurements from every round and the remaining work are in docs/ANDROID_COLLABORATION.md and docs/android-notes/. The HarmonyOS version is in the next section.

The HarmonyOS NEXT app (dm/harmony) is by @biglawine (#114) and uses the same host and the same Vulkan engine as Android. Measured by the author on a Mate 90 Pro Max (Maleoon 955): 59.7 fps holding the joystick in the Rogue Encampment, display interval p50 16.6 / p99 18.1 ms.

How to use it: the same idea as the iOS shell. The Releases page has an unsigned install package that contains no game content (D2RMobile-harmony-shell-unsigned.hap). HarmonyOS NEXT only installs apps signed with your own developer certificate, so you re-sign it with your own debug certificate and install it; you do not build the app yourself. Then, on a computer, run python3 dm/tools/d2rm_android.py --target ohos <Update folder> <output folder> on your own game files to make the runtime pack, put it with the game resources in a "D2R Mobile" folder on the phone, open the app and pick that folder to import. The full steps are in docs/HARMONYOS.md. The author ran the whole chain (re-sign → install → first import → into a game → save and exit) on a Mate 90 Pro Max, with three cold starts in a row working; you need a Huawei developer account (DevEco Studio can generate the debug certificate and register the device for you).

Minimum: an A14 / M1 chip or later — the graphics layer needs Metal 3, which Apple supports from A14 / M1 on (see Apple's Metal support on Apple devices and Metal Feature Set Tables).

What the dialogs in the App mean

• "One More Step for This Device": this phone can run the game; the install package was made without the Legacy Device Pack. Make the pack as in docs/LEGACY_DEVICES.md, make the install package again with it and reinstall.
• "Device Not Supported … iPhone 15 Pro and later can play": this is the old text from before v1.0.9. You are on an old version; update to the latest. For A16 and earlier devices, then follow the line above.

What a package you build yourself does not have, compared with our test-group builds: the public version can be built and installed with a free Apple ID. Three things in our test-group builds are not in it: iCloud save sync (the App needs the iCloud signing entitlement, which a self-signed package does not have), downloading packs and resources inside the App, and new-version notices (these two use our own server). The game itself and the features we added are the same.

Whatever device you play on, you start with the files of the game you bought: the Switch release of Diablo II: Resurrected plus the Reign of the Warlock expansion, updated to 1.0.34.0 (the version the console shows; it corresponds to PC version 3.3.94012, and the directory names and tools in this repository use the latter number). This project is built for the version with that expansion; using it without the expansion is not supported and has not been verified. How to prepare them is in docs/GAME_FILES.md.

This project provides only tools and an install shell that contains no game content. We do not distribute or endorse, and are not responsible for, any third party distributing game assets, game executables or install packages that contain game content. Please use only game files you legally own.

This project is implemented and verified on the Switch release 1.0.34.0 (which corresponds to PC version 3.3.94012), and by default the tools accept only that version. Community users have reported adapting other versions on their own by following the structure of this repository, and running them successfully. The rule tables are grouped by game version (in dm/tools/patch_nso.py, keyed by the build ID of the main program); you are welcome to contribute the version you adapted.

Check your device first and find your section in the table below; the "Which devices are supported" table above tells you which build to use on Apple devices and whether you also need a Legacy Device Pack.

The two routes for iPhone / iPad compared:

The Apple account used for signing: a paid developer account gives you everything; a free Apple ID works too (no iCloud save sync, and the app has to be re-signed and reinstalled every 7 days). The full list of dependencies is in docs/DEPENDENCIES.md.

1. Put your game files in the workspace (default ~/dm-work, or set DM_ROOT):

   ~/dm-work/data/switch/3.3.94012/Update/ExeFS/    main, sdk, subsdk0
   ~/dm-work/data/switch/3.3.94012/Update/RomFS/    data/…
   

2. Prepare the workspace. This checks your tools, rewrites the game program, and translates the game's shaders to Metal. The first run takes a while; later runs skip what is already done.

   ./setup.sh
   source ~/dm-work/build/cache/dm/venv/bin/activate     # run everything after this inside the Python environment setup prepared; if you changed DM_ROOT, use it in place of ~/dm-work
   

3. Fill in your signing details and build the app:

   cp dm/ios/local.env.example dm/ios/local.env     # set DM_TEAM_ID and DM_BUNDLE_ID; with a free Apple ID also set DM_FREE_ACCOUNT=1 and DM_IOS_UDID, and keep the phone connected while building
   cd dm/ios && ./run.sh build    # targets both iPhone and iPad by default; for iPhone only: DM_DEVICE_FAMILY=1 ./run.sh build
   

The first time you open the app on your phone, it asks for the "game resource folder" — the 18 resource archives from your game files. Where to put them is in the section "The "game resource folder" that goes on the phone" of docs/GAME_FILES.md.

./setup.sh check is a health check: it reports the state of this computer, the tools, the game files and the signing configuration item by item, and for everything missing it says where to get it and which command to run next; it changes nothing. If what you have is a whole game package (.xci / .nsp), ./setup.sh <game package> <prod.keys> first extracts the game files into place and then carries on (install hactool first); if the base game and the update are separate packages, give both: ./setup.sh <base game> <update> <prod.keys>. Run ./setup.sh again after every update to a new commit: it rebuilds the patched binaries and the shader library for the current sources (steps that are already up to date are skipped). It also rewrites three files in the repository that change with your local tool fingerprints (dm/gfx/tools/dmsh_chain.lock, dm/gfx/nvn/dmsh_chain.h, dm/gfx/nvn/c1_full.tsv); that is expected, do not commit them.

After the same ./setup.sh, one more command builds a native macOS App that starts on double-click and works with keyboard, mouse and gamepad, with no developer account:

source ~/dm-work/build/cache/dm/venv/bin/activate
dm/tools/mac_app.sh                  # macOS 26 or later: produces ~/dm-work/out/macapp/D2R Mobile.app
DM_MAC_M3=1 dm/tools/mac_app.sh      # macOS 15 – 25: produces D2R Mobile M3.app

The interface is the original's gamepad interface. Keyboard: Space confirms, Esc goes back, Return, the = key opens the menu / a new character, W A S D moves, and every other gamepad button has a key. Mouse: clicking a monster, NPC or object walks over and interacts, and the skill slots, potion cells and key hints at the bottom, buttons and tabs in panels, the class figures when creating a character and the minimap can all be clicked; clicking empty ground walks there and holding keeps walking, clicking a monster attacks it, and items take double clicks and drags. With a keyboard, the prompts on screen show keyboard keys. Saves stay on this Mac (iCloud sync needs a paid developer account and a build with DM_MAC_ICLOUD=1, see docs/MAC.md) and can be imported by hand from an iPhone / iPad. The key table, how to create a character, what the mouse can do, the import steps and the known shortcomings are in docs/MAC.md. Keyboard and a physical gamepad have not been operated by a person yet — if you try it, please tell us how it went.

No Mac, no adb and no building the APK yourself; any Windows / Linux / Mac computer will do (it has been run through on a Mac so far). The full steps, the tools to install and what to do when something goes wrong are in docs/ANDROID.md.

1. Prepare your game files, the same as for Apple devices (docs/GAME_FILES.md).

2. Make the import pack on a computer:

   python3 dm/tools/d2rm_android.py <Update directory of your game files> <output directory>
   

3. Over USB, copy the android folder it made and the game resource folder data to Download/S2X/D2R Mobile/ on the phone.

4. Download D2RMobile-android.apk from the Releases page, install it, open it and allow "All files access"; the App imports the pack and starts the game.

The source must be from the same release as the APK; for a new release, replace both the APK and the import pack, and your saves stay. To build the APK yourself from source, see dm/android/README.md.

You do not build the app yourself. You need a Huawei developer account and DevEco Studio (for its signing tool and hdc; it can also generate the debug certificate and register the phone). The full steps, commands and what to do when something fails are in docs/HARMONYOS.md.

1. Prepare your game files, the same as for Apple devices (docs/GAME_FILES.md).

2. Download the unsigned shell D2RMobile-harmony-shell-unsigned.hap from the Releases page, re-sign it with your own debug certificate and profile (hap-sign-tool sign-app), then install it on the phone with hdc install -r.

3. Make the runtime pack on a computer:

   python3 dm/tools/d2rm_android.py --target ohos <Update folder of your game files> <output folder>
   

4. On the phone, make a "D2R Mobile" folder with the game resources in data/ and the runtime pack from the previous step in dm/, open the app, tap Import and pick that folder.

The source must be from the same release as the shell. For a new release, re-sign the new shell with the same signing and install it over the old one; your saves are kept. The author ran these steps on a Mate 90 Pro Max.

Download our prebuilt "shell" package (D2RMobile-shell-build-input.zip; D2RMobile-shell-ios18-build-input.zip for iOS 18 – 25), which contains no game content, from this repository's Releases page, add your own game files, make the install package on Windows or Linux, then sign and install it with a sideloading tool. The shell is build input, not an app to install (installed as is, it only shows a dialog and does not start the game); when you move to a new release, make the install package again with the new shell. On this route only, because the computer making the package has no Apple shader compiler, the first launch on the phone spends about 7 minutes compiling shaders (once, with a progress bar); a package built with Xcode has no such step. The steps, and how far each one has been verified, are in docs/NO_XCODE.md.

• If you hit a problem, open an issue (there is a template); attaching the file exported by Share Diagnostics in the pause menu helps the most.
• For the items marked not verified, tell us whether they worked or not. Either answer is valuable.
• To change the code: get the test entry points above passing first. Every change has to pass the regression gates.

Taking it to other platforms: this approach is not limited to iPhone and iPad. Apple silicon Macs already have a native version (see "Playing directly on a Mac" above), built from the same game program and the same host; Apple TV also has a community port (developer preview, see the device table). Android has been reached too: since v2.0 there is a community-ported Android version (see "Android" above) built on the same host, with only the graphics layer swapped for Vulkan; a HarmonyOS version has arrived too (see "HarmonyOS" above), sharing the same Vulkan engine.

Taking it to other games: someone has already tried other Switch games on the same host. The host has some behaviour that is on by default on iOS and was written for this one game; another game runs into these first, so turn them off or move them out before you start:

• dm/host/hle_oe.c: the 3D render scale defaults to 0.75 on phones (the Android app sets 0.85), and scale3d_tick rewrites it at offsets inside this game's renderer — with another game that is a wild pointer.
• dm/host/hle_fs.c: seeding the shared stash on first launch (DM_STASH_SEED) and the touch-layout default settings (DM_TOUCH_DEFAULTS) are on by default on iOS.
• dm/host/main.c: the save-flush throttle patches a constant at a fixed address in the game program; argv[0] is hard-coded to "D2R".
• dm/host/hle_time.c: the fixed-time test switch recognises a fixed address in the game program.
• front_game_res in dm/host/front_mac.m: the docked / handheld resolutions are hard-coded to 1600×900 / 1280×720.
• dm/host/dm_cloudsync.c: character directories are recognised by .d2s.
• dm/host/dm_cursor.c and dm/host/dm_world.c: the whole files are specific to this game.

The cleaner arrangement is to move these defaults into per-game configuration and keep the host free of game-specific defaults; pull requests in that direction are welcome.

You must own the game, including the Reign of the Warlock expansion. This is an independent, non-commercial project. It is not affiliated with, endorsed by, or sponsored by Blizzard Entertainment or Nintendo. Diablo and Blizzard Entertainment are trademarks of Blizzard Entertainment, Inc.; Nintendo Switch is a trademark of Nintendo. Use it only with a copy of the game that you own.

The Android version in v2.0 comes from three community authors. Special thanks to:

• @yyan160 (Yuechuan Yang): the Android port itself (#113) — the Android app, the JNI host, the touch overlay, Vulkan presentation, a full round of performance work measured step by step on a phone (the Redmi K50 Ultra camp went from 7.7 fps to a median 60 fps), and the changes that let the shared host build and run on both Apple and Android. Every point raised in review was fixed on the branch.
• @biglawine: the HarmonyOS port (#114) and its NVN-to-Vulkan replay engine, which is where the Android graphics layer comes from; they also set up the Android / HarmonyOS collaboration repositories and generated the shader bundles used for on-device testing.
• @vickwv: a separate, independent Android port (#112). Its ideas were each measured on the Android version, and its 3D brightening approach was adopted.

This project stands on the open-source work below. Thank you to its authors and maintainers.

• Ryujinx (Ryubing 1.3.2, MIT): dm/third_party/ryujinx bundles its shader translator unchanged (the Ryujinx.Graphics.Shader, Spv.Generator and Ryujinx.Common projects), which translates the Switch game's shaders to SPIR-V. During development we also ran the original game in a patched Ryujinx as the reference for comparing pictures and game state (see dm/verify/README.md; the scripts that build and drive it are not in this repository).
• deko3d (devkitPro, zlib): the texture layout size algorithm in dm/gfx/nvn/nvn_tex.c is ported from it.
• nvn.h (h1k421, MIT): the graphics API declarations in dm/gfx/nvn/include/nvn.h.
• libdeflate (Eric Biggers, MIT): decompressing game data.
• bcdec (iOrange, MIT or Unlicense): decoding BC textures on devices that do not support the BC formats.
• FLIP (NVIDIA, BSD 3-Clause): the image difference metric used in image-quality checks.
• Offline fix patch (LFS Mod Offline Fix): the 7 rewrites in dm/tools/patch_nso.py that let the game run offline come from this community patch. We have no reliable record of where it was first published or who wrote it; if you know, please open an Issue.
• Tools used to build and verify: SPIRV-Cross (SPIR-V to Metal Shading Language), XcodeGen, .NET, Capstone and Unicorn (disassembly and equivalence checks of the rewrites), Pillow, numpy, lz4, astcenc (the Legacy Device Pack), hactool (extracting files from a game package), libimobiledevice and LLVM. Versions and links are in docs/DEPENDENCIES.md.
• Community contributions: Joe Hu reported and diagnosed several Greater Rift issues and proposed a verification matrix; seedds found and diagnosed the render-target view format issue on another port (#36). Both are credited as co-authors on the corresponding commits.

MIT, see LICENSE. Third-party code keeps its own license in its own directory; see docs/DEPENDENCIES.md.