PlatinumSharp Is Not an Emulator: Pokémon Platinum's Own Code Runs as C#

By Indie Kings | October 16, 2026

Updated October 16, 2026: PlatinumSharp is a hand-written C# port of Pokémon Platinum (Europe) for the Nintendo DS, and per its repository README it is not an emulator: the game's own code is translated function by function into C# and runs on a small custom engine. It needs your own legally obtained dump of the game, because the repository ships no game data at all.

Image: PlatinumSharp repository card. Credit: GitHub, SatyPardus.

What PlatinumSharp actually is

The usual way to play a DS game on a PC is emulation: the emulator reimplements the console's hardware and feeds it the original machine code. PlatinumSharp, a GitHub project by SatyPardus, takes a different road, and the README states it plainly: "It is not an emulator."

Per the README, the game's ARM9 binary and its overlays are translated function by function into C#. That C# runs on a small custom engine which reimplements only the DS hardware the game depends on: 2D and 3D rendering, OAM, DMA, timers, sound and the touch screen.

Everything the code reads stays out of the repository. Graphics, maps, scripts, text and music are read directly from the user's own ROM at runtime, so the port's source tree holds translated logic, not game assets. The README says it in bold: "No game data is included."

The failure mode that names the missing address

The most unusual part of the design is what happens when the port meets code it has not translated yet. Per the README, functions that have not been ported are reached through stand-ins in Game/Unported*.cs, and each stand-in throws a NotImplementedException that names the original function's address, for example "Function 0x02040D08 is not ported yet". The game stops cleanly and tells you exactly what it is missing.

The same discipline runs through the whole codebase. Every ported function carries a comment with the address of the original function in the ROM, in the form // OFFSET 0x02040D08 above a method such as ScrCmd_ShowMenuMultiColumn. That makes every line of the C# traceable back to a specific address in the European Platinum binary.

Naming follows the community pret/pokeplatinum decompilation where a name for a function, structure or constant exists, per the README. Where no name exists, the symbol gets a descriptive name of the project author's choosing. ROM tables are read from the ROM at runtime through a RomData layer rather than copied into the source.

What works today, per the README

The project is a work in progress, and the README is specific about where it stands. The game boots, plays the opening and the new-game intro, and the overworld, battles, menus, the Pokétch and many script commands work. Large parts of the game are still unported.

The scale so far: roughly 11,000 functions of the game's ARM9 binary and overlays have been ported, each one marked with the address of the original. The README offers a second yardstick for completeness. The game's scripts contain more than 55,000 script commands, and coverage of those commands is what the project treats as a rough measure of how much of the game is playable.

Seven projects and what each does

The solution splits the work into seven projects, and the README describes each one's output and purpose:

The Game and Nitro libraries are the core, Runner is the player-facing window, and Tool, ScriptPlayer, Viewer and Preview are the workbenches: three of them exist mainly to see inside the port and the ROM rather than to play.

Headless testing and the automated explorer

Tool can boot the game without a window at all, which the README says is useful for tests and for finding the next unported function. The README's example boots the game for 3,000 frames and presses Start at frame 620 to skip the opening movie. The run either prints which function stopped it or confirms it went the whole distance without reaching unported code.

Runner takes the same idea further with options for scripted or automated use: flags that capture a screenshot to a PNG, cap the frame count, inject button presses at chosen frames, record a WAV, mute audio, set the playback speed, and run a test script against a saved state with a result file. In other words, the port is built to be driven by machines as much as by players.

The exploration layer is the most ambitious part. Per the README, a test-script system runs simple text steps such as talk, goto x z, warp <map>, save <name> and explore <n>. In explore mode an automatic player walks the overworld and decides where to go next.

That automatic player does real work. It records every field-script command it executes and which flags and variables each script read, saves the record to disk, and uses it to find scripts and branches it has not seen yet. It plans routes around water and down one-way ledges, avoids triggers it already knows, fights wild battles by picking the strongest move with PP left and fleeing when low on HP, and heals at Pokémon Centers it has found.

Requirements and default controls

The toolchain is Microsoft's .NET 8 SDK. Per the README, the graphical programs (Runner, ScriptPlayer, Viewer, Preview) use WinForms and NAudio, so they need Windows; the Game library, the Nitro library and the command-line Tool instead target plain net8.0. Building is one command: dotnet build PlatinumSharp.sln -c Release.

Default keybinds, rebindable in the Runner window, map the DS controls to a keyboard as follows:

Launching the game opens a file dialog to pick a ROM, or the ROM path can be passed on the command line. For the test tooling, the README describes a workspace layout that lives next to the repository, with environment variables such as PLATINUMSHARP_WORKSPACE and PLATINUMSHARP_ROM to override it, and notes that none of these are needed just to play the game.

The ROM requirement and the legal line

This part matters most, so it gets its own section: PlatinumSharp is unusable without a ROM you supply yourself. You need your own dump of Pokémon Platinum Version (Europe) as an .nds file, and the README says so in bold. The repository contains no game data: no graphics, no maps, no scripts, no text, no music. That is a legal line, not a technical one.

The README's own disclaimer states the project is not affiliated with or endorsed by Nintendo, Game Freak or The Pokémon Company, and its Legal section adds that Pokémon and all related names are trademarks of Nintendo, Creatures Inc. and Game Freak Inc. It also states that you must own the game and provide your own dump to use the port.

We will not point to ROM downloads here, and the project does not either. The port reads whatever ROM you give it, from your own copy of a game you own. If you cannot legally produce that dump where you live, this project is not your path to playing Platinum.

FAQ

Is PlatinumSharp an emulator?
No, per its README. The game's ARM9 binary and overlays are translated function by function into C# and run on a custom engine that reimplements the DS hardware features the game uses. The original machine code never runs.

Do I need a Pokémon Platinum ROM to use it?
Yes. The repository includes no game data, so you must supply your own dump of Pokémon Platinum Version (Europe) as an .nds file, and you must own the game.

How much of the game is playable right now?
Per the README, the game boots and plays the opening and new-game intro, and the overworld, battles, menus, Pokétch and many script commands work. Roughly 11,000 functions are ported, but large parts of the game are still unported.

What happens when the port hits unported code?
A stand-in throws a NotImplementedException that names the missing function's address, such as Function 0x02040D08. The headless Tool also prints which function stopped a run.

What do I need to build and run it?
The .NET 8 SDK and a build with dotnet build PlatinumSharp.sln -c Release. The windowed programs need Windows because they use WinForms and NAudio; the Game and Nitro libraries and the Tool run on plain net8.0.

How does the project know the original function names?
Every ported function carries a comment with the original ROM address, and names follow the community pret/pokeplatinum decompilation where one exists. Symbols with no known name get descriptive names.

Our take

I think the address-naming failure mode is the smartest thing here. A port of this size is a wall of unknown unknowns, and "Function 0x02040D08 is not ported yet" turns that wall into a queue: the game itself tells the developer what to translate next, and the headless Tool turns that into a testable loop.

I also think the distinction from emulation is worth celebrating rather than nitpicking. An emulator aims to run any disc or cartridge you throw at it; this project produces a readable, comment-marked C# document of how one specific game works. Those are different goals, and only one of them teaches you the game's internals in your own source tree.

Bottom Line

PlatinumSharp is a hand-written C# port of Pokémon Platinum (Europe) that runs the game's translated ARM9 code and overlays on a small custom DS-hardware engine, per its README. It boots, plays the intros, and runs overworld, battles, menus and Pokétch on the back of roughly 11,000 ported functions, with unported code stopping cleanly and naming the missing address. It ships no game data, needs Windows plus the .NET 8 SDK for the windowed programs, and requires your own legally obtained dump of the game.

Sources

PlatinumSharp repository README (SatyPardus, GitHub)