Two copies of PictoChat exchanging messages might look like a modest achievement beside a modern online game. For Arisotura, getting those instances to communicate was an early breakthrough in a much harder problem: making Nintendo DS local wireless work in an emulator. New Super Mario Bros. followed, with Mario and Luigi sharing a game through an early version of melonDS.
To try the project, download melonDS from its official GitHub releases. The official melonDS website carries the project’s development posts, while the source repository hosts the code. Those are the project’s own resources.
Arisotura’s route into emulation began elsewhere. In 2007, trying to run PlayStation 2 games led to PCSX2, broken terrain textures in Worms 3D, and a growing curiosity about how any of it worked. Experiments with plugins, DeSmuME, and SNES emulation eventually led to a fresh DS project in 2016.
That project required much more than drawing both screens. The DS’s polygon renderer behaved in ways that ordinary triangle-rendering examples did not cover. Wireless games expected replies within tiny timing windows. DSi cameras added another stream of data that software expected to arrive at the right speed. In the answers below, Arisotura describes the tests, wrong turns, and compromises behind making those pieces work together.
There is also the work of sharing a codebase, learning from contributors, and staying motivated when a project keeps branching into new problems. Arisotura discusses all of it here, including the games that remain enjoyable after the debugging stops. Our melonDS emulator page provides a shorter overview and setup links, and the emulation history hub follows the wider scene.

From broken PS2 graphics to writing emulators
Retro Replay: Let’s start with a traditional one. What originally got you interested in emulation deeply enough that you went from using emulators to actually writing them?
Arisotura: It all happened in 2007. Simply, I wanted to play some PS2 games, but couldn’t access our PS2 at the moment, so I wanted to try PS2 emulators. I had some experience with emulators (namely, for 68k Macs), but didn’t really know what to expect.
I recall finding and trying three different PS2 emulators, among which, the famous PCSX2. It was the only one of them that was able to boot commercial games, but at the time it was way too janky and slow to be playable. I remember how Worms 3D had all its terrain textures replaced with random junk, for example.
Regardless, I became fascinated by this emulator, and even tried different games to see how they would run. I got very interested by the technical aspect of it all, wanted to develop my own plugins for PCSX2, and eventually did so with some success, despite being very inexperienced.
Retro Replay: Before melonDS, you had already worked on projects like DeSmuME and blargSNES. What did those earlier projects teach you that directly influenced the way you approached melonDS?
Arisotura: DeSmuME was a great occasion to learn how an emulator works, how all the various modules mesh together, and how to debug emulation issues. When I first started messing with DeSmuME, I was quite inexperienced, but I gradually figured out how things work by experimenting.
DeSmuME also served as an inspiration for some technical aspects of melonDS.
blargSNES is a bit of a different situation: it is a port of an older project, lolSNES.
lolSNES was meant to be a SNES emulator for the DS. Although I took inspiration from SNemulDS, a smiliar project, it was my first time writing an emulator from the ground up. I had made some attempts before, but they never went anywhere because I was too inexperienced.
blargSNES is basically lolSNES ported to the 3DS. Some changes had to be made to get it to run on this platform, but for the most part, not much was changed besides PPU emulation. I ended up writing a new hardware-accelerated renderer, which was a great occasion to learn about modern(ish) GPU hardware.
Starting fresh with melonDS
Retro Replay: When you began melonDS in 2016, you said you were largely doing it for the challenge and because the DS emulation scene needed some fresh air. Was there one specific limitation or frustration that finally made you decide, “I’m just going to start my own emulator”?
Arisotura: The basic story is that DS local multiplayer happened to pique my interest again. I had tried to emulate it before, but never had success.
Originally, since I had experience with DeSmuME, it kind of made sense to just work with it, but I knew the DeSmuME team’s stance wasn’t really favorable to anything wifi (if you visit their site, you’ll know what I mean). So my idea was to fork DeSmuME and do my own thing.
However, I ended up scrapping that idea and instead deciding to start fresh. I figured it would be better to start with a blank slate than have to deal with all the problems of what was a decade-old project, and writing my own emulator from scratch would be a lot of fun and a great occasion to learn.
Retro Replay: The very early goal was to boot through the actual DS BIOS and firmware rather than simply jumping directly into a game. Why was doing that correctly important to you from the beginning?
Arisotura: My idea was that if I could successfully emulate the console’s normal boot process, I would have a solid foundation to work on.
I added support for booting ROMs directly quite early on, for the sake of convenience, but it could be tested against a normal boot for correctness. The BIOS and firmware do some amount of hardware and memory setup before booting a game, and you never know when some minute part of this ends up being important to a given game.
Retro Replay: Do you remember the first time melonDS successfully reached the DS firmware menu?
Arisotura: Was that one of those moments where the project suddenly started feeling like a real emulator instead of a pile of half-working hardware code?
I do remember it. The first screenshot of melonDS was exactly this. It was full of bugs, but it was displaying the DS menu.
It feels like a first milestone. It’s difficult to start an emulator project because your initial development phase doesn’t really give tangible results beyond « I am able to run this or that CPU instruction successfully ». But once melonDS was past this stage, things felt exciting. It was actually running and rendering stuff, feeling like a real emulator as you said.
Two processors and one stubborn timer
Retro Replay: The Nintendo DS has two ARM CPUs running together. How much harder is it to reproduce the timing and communication between the ARM9 and ARM7 than to emulate either processor individually?
Arisotura: In general, games don’t require tight synchronization between the two ARM CPUs. melonDS runs each CPU for up to 64 cycles before switching. From other devs’ experience, it appears that you can get away with much bigger time slices.
Communication between these two CPUs is largely done through the IPC FIFO: a simple hardware message queue where one CPU may write data, and the other CPU will be notified by an interrupt, so it may read out that data. Not a lot that can go wrong.
The ARM7 also doesn’t have much of an impact, in general. In most games, it doesn’t do much work compared to the ARM9, and it runs off its own internal memory, not hitting the main RAM a lot.
However, there are a few cases that rely on memory contention: when both CPUs are trying to access main RAM at the same time. In this situation, one of them is given priority, and the other has to wait. It seems to be a very simple arbitration mechanism, which may end up starving one CPU.
This would be impossible to model properly within melonDS: it would require cycle-accurate emulation, and melonDS was just not built for this.
Retro Replay: Was there a particular IPC, DMA, interrupt, or synchronization bug that drove you completely insane during early development?
Arisotura: I remember this really odd bug I ran into when trying to run the DS firmware. Basically, the firmware would keep setting up a hardware timer in such a way that it would fire an IRQ after a tiny amount of cycles. Every time, it would process the IRQ then set up the timer again, in the same way. Because of this tiny interval, the firmware was stuck doing that over and over, and wouldn’t do anything else.
The bug turned out to be related to a specific variant of the LDM instruction which the firmware used when switching between threads.
Teaching a renderer the DS’s peculiar rules
Retro Replay: The DS combines 2D hardware with a surprisingly capable 3D engine. You’ve written that the melonDS 3D renderer was your first polygon rasterizer. What was the biggest thing you had to teach yourself while building it?
Arisotura: I had to figure out how I was going to write a suitable polygon rasterizer, something I had never done before.
Your typical 3D rasterizer example knows how to draw triangles, but that’s about it. The DS, however, isn’t limited to triangles. It can natively handle quads, but not only: due to the way clipping works, a polygon can end up with up to 10 edges.
I did a lot of hardware tests, back then, to figure out how the DS renderer works. When reverse-engineering hardware, sending marginal or outright invalid input can give insight into how the hardware works under the hood. This is especially true of the DS’s 3D rasterizer: make it draw non- convex polygons and it will tell you a lot about how the rasterizer works.
Retro Replay: Once you began testing the real DS GPU, did you discover rendering behaviors or shortcuts that were very different from what you expected from a conventional PC graphics perspective?
Arisotura: Oh yeah ! I even dedicated a few blog posts to it: here (https://melonds.kuribo64.net/comments.php?id=56) or here (https://melonds.kuribo64.net/comments.php?id=85).
In particular, I think their approach to perspective correction is quite clever. Perspective-correct interpolation involves a lot of divisions, which are costly. They reduce it to one division per pixel by precalculating a perspective-corrected interpolation factor, which is then used to quickly interpolate the actual vertex attributes.
This is the best I can explain it here without going far in depth. If you’re tech-savvy and want to know more about this, you should definitely check out the blog posts I linked!
Retro Replay: Was there a game or hardware test that forced you to rethink a substantial part of the 3D renderer?
Arisotura: I think if anything forced me to redo parts of the renderer, it wasn’t so much a singular game, but rather my findings showing the hardware is weirder than anticipated…
The games that break things, and the games worth playing
Retro Replay: What DS game has caused you the most pain as an emulator developer?
Arisotura: I don’t think I can name one specific game. Maybe Sonic Chronicles?
In general, it is games that exhibit timing issues. But it’s not really like older consoles, like the NES or GameBoy, where games might try to make the most out of the limited hardware. In the case of the DS, most timing issues I’ve seen boil down to shoddy concurrent programming. Sonic Chronicles is no exception.
It’s particularly painful when those rely on accurate CPU timings. With timings, you need to get the base timing model right or you’ll be playing a perpetual game of whack-a-mole: nudging timings to fix game A, but doing so breaks game B, and so on. Most hardware components in the DS have a fairly simple timing model, but the ARM9 is way more complex in this regard.

Retro Replay: On the opposite side, what DS game do you personally enjoy the most when you’re not staring at it as a compatibility test?
Arisotura: Hard to say, but back then I’ve liked New Super Mario Bros. a lot.
I also remember that for a while I was playing Picross 3D in melonDS. Not trying to fix bugs or anything, just playing the game. I quite like the concept behind that game.
Browse Picross 3D and New Super Mario Bros. in Retro Replay’s Gamebase.

Getting two handhelds to talk
Retro Replay: Local wireless was one of melonDS’s original “holy grail” goals. Why is DS local multiplayer so much harder to emulate reliably than people might assume?
Arisotura: Long story short is that it relies on an old 802.11 feature called PCF, or a customized form of it.
During a multiplayer game, the host periodically sends a data frame to its clients. This frame is configured in such a way that extra time is allotted after it is sent, where the clients may respond freely. The clients which get polled are expected to respond, even if they have nothing to say – a lack of response is considered a network error. Each polled client has its own window for responding, and the tolerance is in the order of microseconds.
In the wifi world, there is no such concept as frames getting delayed. Well, before you can send a frame, you may have to wait until noone else is sending frames, but once a frame is sent, it is either received on time or not received. This is in contrast with wired networks, where frames may get delayed.
That’s the main reason. There is leeway in how long the transmission of the host’s initial data frame can be delayed. It’s possible to use this to our advantage, but delaying things too much causes slowdown, so it’s not like we can completely abuse this.
Retro Replay: When local multiplayer finally started working properly, was there one game or multiplayer session where you thought, “Okay, we actually pulled this off”?
Arisotura: My first successful experiment was with Pictochat. There is that famous screenshot of two Pictochat instances successfully communicating.
However, the second game we tried was New Super Mario Bros.
https://www.youtube.com/watch?v=nJsGyTb71e0 Ah, melonDS 0.4. Such a throwback. Was kind of a miracle that local multiplayer worked at all, given the kind of issues it had, but hey, that was still quite the feat.
Retro Replay: Mario Kart DS seems almost like the obvious torture test for wireless emulation. Has it been particularly useful for exposing timing or packet-loss problems?
Arisotura: I remember that game being problematic, but I don’t quite remember the specifics…
Either way, the main issue with local multiplayer has always been (and still is) getting all players connected. Once they’re connected, melonDS’s synchronization mechanism kicks in and everything is generally rock solid. But the connection process happens with no real way to synchronize things, which causes all sorts of problems.

Local wireless, LAN, and online play are different problems
Retro Replay: melonDS has gone through several approaches to networking, from early packet forwarding and libpcap experiments to libslirp and newer LAN synchronization work. What did each failed or imperfect approach teach you about what the emulator actually needed?
Arisotura: All the network terminology can get a little confusing…
libpcap and libslirp are about online multiplayer, ie. connecting melonDS to the internet. In this instance, melonDS emulates an access point the game can connect to. Direct and indirect (aka libpcap and libslirp, respectively) are ways to connect said access point to the real network.
The libpcap method is nice because it’s functionally simple: network frames coming in and out of the emulated access point are simply routed straight through the host machine’s network card, and the emulated DS appears as a real device on your network.
The downsides are that it requires installing libpcap, which requires admin privileges. In some instances, you might also need to run melonDS with the same sort of privileges. Also, this method only works with ethernet connections.
The early packet forwarding attempts were aimed at overcoming those limitations. My idea was to dissect network traffic at a higher level (think TCP/UDP) and replicate it with simple BSD sockets. I did eventually get it to work, although it had some weird problems. It also tended to kill connections on the host machine, due to it appearing the same as the emulated DS.
I eventually found libslirp, and, well, since it does what I wanted to do, I gave it a try. The biggest problem was figuring out how to use libslirp, since there was no documentation…
In the end, libslirp is the preferred method. There’s more complexity internally, but the end user doesn’t need to concern themselves with any of it: libslirp generally « just works », requiring no setup.
LAN is a different thing. It’s about local multiplayer.
Basically, in the early days of local multiplayer, the actual networking was implemented in a very crude way: outgoing frames were simply tossed over UDP, hoping that other melonDS instances that happened to be around would receive them on time.
Of course, it caused a bunch of problems, but this approach had one advantage: it was theoretically possible to play local multiplayer games over the network. It generally didn’t work at all unless you had a really good local network, but the possibility was there.
Eventually, the UDP system was ditched in favor of a properly synchronized system, relying first on shared memory, then on just running multiple melonDS instances within one process (the big 1.0 refactor). While those guaranteed much more reliable networking, you were constrained to having all players play on the same machine.
LAN was devised to work around that. The basic idea was to extend the synchronization system to work over the network. It works, but there are still issues… and again, requires a fairly good network. It generally doesn’t work over wifi, which is a bit ironic.
Retro Replay: One of the strange things about better emulation is that it can sometimes make networking less forgiving because you are reproducing real hardware timing more accurately. Has that been one of the more counterintuitive problems you’ve faced?
Arisotura: There have definitely been cases of better emulation making things worse, indeed.
A great example was when I was trying to fix all the problems local multiplayer had, back in 2022. It took one month of research, and gave birth to the local multiplayer saga, which spans 10 episodes (https://melonds.kuribo64.net/comments.php?id=162).
Retro Replay: Online connectivity also raises the weird preservation problem of emulating hardware designed to connect to services that no longer officially exist. Do you see custom WFC servers and emulator networking as part of preserving the original experience of DS games?
Arisotura: Absolutely!
Fun fact, I have ideas in mind for netplay, but motivation to carry it out has been lacking…
The DSi adds a new set of puzzles
Retro Replay: The DSi significantly complicated the project with additional hardware, NAND storage, cameras, more memory, new Wi-Fi hardware, DSP functions, and security. At what point did you decide full DSi support was worth taking on?
Arisotura: « Hey, this looks like an interesting problem, let’s solve it! »
That’s my brain in a nutshell.
Retro Replay: What part of the DSi turned out to be much nastier to emulate than you originally expected?
Arisotura: I can think of atleast two…
There is SD/MMC support. There are two SD/MMC controllers in the DSi: one of them is connected to the internal NAND and the SD card slot, and the other is connected to the wifi card.
Getting SD/MMC emulation working proved to be tricky, with all the edge cases that can happen during block transfers. This code was written with a mindset of « make it work first, make it pretty later », and it shows – I still need to actually « make it pretty ».
There is also the DSi’s built-in cameras. The DSi has a piece of hardware which receives picture data from either camera, and provides support for DMA so that said picture data can be automatically stored in RAM.
Emulating this proved to be trickier than expected. At first, it took me some time to figure out how this hardware works and how the DMA logic is supposed to work.
And then it turns out you can’t just blast picture data at the game and expect it to deal with it. For various reasons, games are more or less sensitive to the rate at which data is transferred, so I ended up having to research and reproduce the real world timing model for camera transfers.
Retro Replay: Conversely, was there some supposedly scary part of DSi hardware that ended up being surprisingly straightforward?
Arisotura: I guess I could mention the DSi’s new audio interface (which lets you change the audio sample rate, provides an interface to the built-in microphone, and other niceties).
I had to rework the way melonDS output audio so that different sample rates could be supported, which was probably the hardest part. Beyond that, the hardware itself was rather simple to emulate.
Knowing when to emulate and when to translate
Retro Replay: melonDS 1.1 added DSP high-level emulation to make certain DSi software much more practical to run. Do you generally prefer low-level hardware emulation when possible, or are there cases where HLE is simply the more sensible engineering choice?
Arisotura: Low-level emulation is not only more authentic to the original hardware, it also covers all the possible use cases. In the case of the DSP, if someone were to write their own DSP code, LLE would be able to run it.
However, there are situations where HLE makes sense, and the DSP is one of them. As far as commercial games are concerned, there is little variation among the DSP programs used, which makes HLE viable. Not to mention the huge speed benefit – emulating the entire DSP isn’t cheap.
However, HLE means we merely identify the DSP program the game has uploaded, then choose to ignore it, using our own native code implementation instead. This only works as far as we actually have a native code implementation to use. In the aforementioned case of someone writing their own DSP program, this wouldn’t work. (In practice, in such a situation, melonDS would fall back to LLE)
Here, I guess the best of both worlds would be some form of DSP recompilation.
Then you also have things like the DSi’s wifi card, which also has its own CPU. This will always be running the same firmware (which is uploaded by the DSi menu), so here HLE is a no-brainer. At the time of writing this, I only know of one case of uploading custom code to the wifi card, and it’s that « break emulators in cheeky ways » demo.
Retro Replay: How do you decide when an emulation shortcut is acceptable versus when it crosses the line into something that will eventually cause compatibility problems?
Arisotura: An example of an acceptable shortcut would be, say, skipping the more minute aspects of emulation that would be very time-consuming to emulate and that no games are known to rely on. Or faking them to an acceptable degree if anything happens to rely on them.
However, without some proper testing, it can be hard to tell what is necessary and what isn’t.
A basic example is how we balance emulating two CPUs. We could run them in lockstep: one cycle for the ARM9, one cycle for the ARM7. It would be the most accurate way, but also the slowest, due to constantly switching between different tasks. Running each CPU for more cycles increases efficiency, but reduces accuracy. It no longer mirrors the fact that in a real console, those two CPUs are running concurrently.
The maximum CPU batch size in melonDS is 64 cycles. According to my measurements, it seemed to be the sweet spot. Bigger batch sizes didn’t seem to result in noticeably better performance, but surely enough, if we keep increasing it, there’ll be a point where the batch size is too big to run some games smoothly.
Hardware research and a shared codebase
Retro Replay: Hardware testing and documentation have clearly been crucial to the project. How much of modern DS emulation is still based on discovering undocumented behavior rather than simply implementing information that is already known?
Arisotura: I would say, quite a bunch of it.
Much of the research on the inner workings of the 3D engine is original, and is infact still ongoing.
Similarly, the wifi features used for local multiplayer were largely undocumented until I worked on it.
Even simpler stuff, like the interface for accessing the game cartridge, can teach us new things. It was discovered that said interface uses a double-buffering scheme to speed up data transfers, and afaik that bit is still undocumented.
Retro Replay: How important have people like nocash and the wider reverse-engineering community been to melonDS?
Arisotura: Is modern emulator development inherently collaborative even when one person originally starts the project?
Absolutely is! It would have taken much longer to get melonDS going if I had been starting from zero.
In a way, we’re all iterating, building upon something that was already there. melonDS draws inspiration from DeSmuME, which itself drew inspiration from early efforts at reverse-engineering the DS. And eventually, you will have newer projects drawing inspiration from melonDS and taking it further, too. Check out DualSOUP, for example, it is an attempt at cycle-accurate DS emulation.
Retro Replay: melonDS began as a personal project, but today the release notes include contributions from a substantial group of developers. Was it difficult learning to let other people work deeply inside code that originally existed entirely in your own head?
Arisotura: It was indeed difficult to accept that the codebase was no longer completely mine, but part of a shared project. It can be difficult for me to trust other people with something I’ve created. It was for the best, though: melonDS wouldn’t be where it is today without those contributors!
The JIT and the people who made it faster
Retro Replay: Has another contributor ever implemented or improved something in melonDS in a way that made you think, “That’s much better than how I would have done it”?
Arisotura: Generic and his JIT recompiler, pretty much.
I had plans to write a JIT, but I’ve never actually written one before, and I’m not familiar with this domain. I only have a general idea of how they work. I don’t think I could have made it as good as Generic did.
I still intend to write recompilers, though, be it JIT or static recompilation. Maybe in melonDS, maybe in other projects.
Retro Replay: The JIT recompilers dramatically improved performance on x86-64 and ARM64 systems. How difficult is it to make a JIT fast while still preserving the timing relationships that DS software depends on?
Arisotura: It’s all a matter of compromise.
On one hand, the whole point of the JIT is to run large batches of DS code at once, skipping a lot of the per-instruction work the interpreter does. On the other hand, when running a whole block of code at once, you can’t really do other things inbetween, like handling hardware events, which may cause them to be delayed.
You could set your JIT to run one instruction per batch, that would be accurate but that would negate the benefits of the JIT. On the flip side, there’s a point where larger batches yield diminishing gains in performance and begin to cause problems. So it’s all about finding the sweet spot for most games.
Generic could probably answer this in more detail, given he made the actual JIT.
Version 1.0, motivation, and the next branch
Retro Replay: After years of working toward it, melonDS finally reached the 1.0 milestone. Did putting “1.0” on the emulator actually feel meaningful, or did it immediately turn into “great, now here are fifty more things to fix”?
Arisotura: 1.0 was a bit of a milestone. There was a large refactor of the codebase, which enables running multiple melonDS instances into one process.
I also didn’t feel like going on forever with 0.9.x version numbers. After all, at this point, melonDS is a fairly solid emulator, it deserves its 1.0 milestone.
But, of course, the project is still far from finished. I like to compare an emulator project to a tree: when you’re done with the trunk, it branches off into a billion directions.
Retro Replay: You’ve written openly about the difficulty of staying motivated on a project that effectively never ends. Has one of the hardest parts of melonDS ultimately been psychological rather than technical?
Arisotura: For sure.
I guess ADHD doesn’t help. It can feel daunting to get started on a bigger project. Like my brain can’t really grasp it, like the object is slippery.
Retro Replay: Does working on something like hardware repair, where a problem has a clear beginning and end, feel refreshing compared with emulator development where there is always another feature, accuracy bug, or edge case waiting?
Arisotura: It does!
Although sometimes you meet problems that are more complicated than anticipated, and it becomes a bit of an adventure. As an example, at work, they have those beefy HMI ballasts (basically, the power supply for a HMI lamp), and two of them had been broken for years, with nobody being able to repair them. When I looked into it, it felt overwhelming at first. These ballasts are full of various circuit boards, ribbons, coils, stuff. It takes a while to get an idea of what does what. To make matters worse, those ballasts had also been more or less modified by previous technicians, so we had to figure that out too. It took several months, but in the end, we managed to fix them up.
Another aspect is that smaller tasks, with a clear goal in sight, feel easier to grasp to my ADHD brain.
The mysteries still waiting inside the DS
Retro Replay: Fun hypothetical: if Nintendo handed you complete internal documentation, schematics, source code, and engineering notes for one part of the DS or DSi hardware, what would you ask for first?
Arisotura: It would be very interesting to learn about the 3D engine’s inner workings. Figuring out the exact algorithms it uses is still an ongoing goal in the DS emulation scene.
But hey, reverse-engineering is a game, and reading official code/documentation would be cheating, kind of like looking up the solution to Myst 😛
Retro Replay: Another fun one: if you could erase your memory of one DS game and play it again completely fresh, which game would you choose?
Arisotura: Could be fun to do that with New Super Mario Bros. for the sake of nostalgia!
Retro Replay: Looking back to the first melonDS release, which you openly described as inferior to the existing emulators at the time, what part of the current project would have been hardest for 2016 Arisotura to believe?
Arisotura: Simply what melonDS has become and how far it has been.
I had originally started melonDS because it was the perfect way to pass time while I was waiting to start that job. I had no idea it would become popular.
Having a project last 10 years is a miracle for me. It has never happened before. It’s hard to stay motivated and focused when you have ADHD…
In retrospect, I think the whole local multiplayer quest helped boost melonDS’s popularity : it went from being a mere curiosity to being that emulator that does something new.
Projects and resources to explore
Retro Replay: Finally, when this interview is published, are there any melonDS resources, GitHub pages, documentation projects, hardware-testing efforts, custom WFC services, current projects, or anything else you would like me to direct readers toward?
Arisotura: One project that’s definitely worth checking out is DualSOUP, by Jakly. The goal is cycle-accurate DS emulation. If this turns out to be feasible at playable speeds, it might advance the DS emulation scene.
(https://github.com/Jaklyy/DualSOUP)
There’s also an ongoing effort to reverse-engineer and document the more obscure aspects of the DSi, and make it more accessible to homebrewers and such.
Download and follow melonDS
Get current builds from the official melonDS release downloads, read development posts at the project website, and explore the source code. Arisotura also recommends Jakly’s DualSOUP project in the final answer. For a concise overview and links back to those resources, visit Retro Replay’s melonDS page.
Thank you, Arisotura
Our thanks to Arisotura for these detailed answers and for sharing the experiments behind melonDS. We appreciate the time spent explaining the hardware, crediting contributors, and pointing readers toward the research still underway.
The featured collage uses Arisotura’s public GitHub avatar as a profile image, rather than a photographic portrait.
Retro Replay Retro Gaming History, Reviews & Emulation
