Dolphin Emulator Blog

I did this, but with Plex (I am a Plex user across multiple devices). I use the computer in clamshell mode with HDMI to my living room TV. Also, I use Rowmote[0] to control the computer -- an old Macbook -- from my phone and run OpenEmu[1] next to Plex for a home arcade solution. I use a Bluetooth PS3 controller for the arcade. SNES works great with Sixaxis controllers, N64 is possible. Havent tried Dolphin[2] yet... But looking forward to it. Late 2011 MBP for the curious, runs great for the above uses. 0. http://regularrateandrhythm.com/apps/rowmote-pro/ 1. http://openemu.org/ 2. https://dolphin-emu.org/

The N64 has a GPU, which is not the same as modern GPUs, and you need that GPU to render graphics. Skimming the Github repo, looks like this uses rt64 under the hood for the raytracing support ( https://github.com/rt64/rt64 ), and that uses the ubershader technique to emulate the GPU. This excellent article talks about the what, why, and insanity that are ubershaders: https://dolphin-emu.org/blog/2017/07/30/ubershaders/

My personal favorite is the This Week In[0] series of posts, if you want a simple way to keep track of notable changes. Technical blogposts are a pretty common practice among reverse-engineers, too; the Dolphin emulator has some great breakdowns[1], along with the people who reverse-engineered the Nintendo Switch's boot process[2] (and the rest of LiveOverflow's stuff). The Asahi writeups are great, but certainly not all there is. Tons of reverse-engineering stuff and Linux documentation gets submit to this website, it just doesn't generally do as well in the ranking system. [0] https://thisweek.gnome.org/ [0] https://pointieststick.com/category/this-week-in-kde/ [1] https://dolphin-emu.org/blog/ [2] https://youtu.be/Ec4NgWRE8ik

Asahi Linux progress reports rank up there with Dolphin[1] progress reports for being excellent examples of technical writing as well as simply reminding me why I fell in love with computers in the first place. Love reading this stuff even if I may never use it (although I would love to run Linux on M1 hardware someday!). [1] https://dolphin-emu.org/blog/

Dolphin (wii / gc emulator) blog is great: https://dolphin-emu.org/blog/

I really enjoy reading about some of the techniques the developers use to get the most out of the hardware. Here are some of my favorites from recent memory: https://medium.com/@gordonnl/wind-waker-graphics-analysis-a0b575a31127 https://blog.mecheye.net/2018/03/deconstructing-the-water-effect-in-su… https://dolphin-emu.org/blog/2014/03/15/pixel-processing-problems/

Oh man, Factor 5 is infamous for doing wild things on consoles. A little bit about their custom N64 GPU microcode is discussed here: https://thesolidstategamer.wordpress.com/2014/07/18/playstation-versus… Edit: Developer interview here https://www.ign.com/articles/1998/02/27/journey-to-the-center-of-the-n… and much more in-depth technical examination here https://olivieryuyu.blogspot.com/2020/01/introduction-factor-5-used-to… Factor 5 did so many wild things to the GameCube, they have their own tag on excellent Dolphin blog: https://dolphin-emu.org/blog/tags/Factor5/

Proton has been fantastic for me, it finally gave me what I needed to reclaim my Windows partition and go full-on Arch! In some cases, running the Windows version inside Proton has actually worked out better for me than the native port (Dead Cells, for example. The native port crashes the Steam overlay and lacks Steam Controller support, but running the Windows version in Proton is seamless) I highly encourage you guys to check out the tech making this possible: DXVK. It's incredible what you can do with these lower level APIs. I'm not sure if this is the right word, but "meta shader pipelines" like this are absolutely the way of the future in emulation. See also: Dolphin Ubershaders. Ubershaders: https://dolphin-emu.org/blog/2017/07/30/ubershaders/

I love reading these kinds of reverse engineering discovery tales, I find them technically educative, and overall enlightening... they help put my own struggles debugging thorny things into sharp perspective, making me even more appreciative of the level of control I have over my own code and it’s runtime environments. The level of effort put into reverse engineering for emulating classic hardware of all kinds is just remarkable. The Dolphin EMU team has a long history of these kind of blog posts for people looking for more of this kind of writing https://dolphin-emu.org/blog/

I suggest checking out the Dolphin Emulator tech blogs as well, they're also consistently great in quality. https://dolphin-emu.org/blog/

Fiora refactored the MMU code emitted by Dolphin to a far jump, which had significant performance improvements over inlining the code [0]. She had an article about it in PoC || GTFO [1]. [0] https://dolphin-emu.org/blog/2014/09/30/dolphin-progress-report-septem… [1] https://github.com/angea/pocorgtfo/blob/master/contents/issue06.pdf#pa…

The Dolphin emulator [0] and Krita [1] are two that come to my mind. [0] https://dolphin-emu.org [1] https://krita.org/en/

These reports are amazing, even though it's hardly understandable if you're not on the project. I recommend the Dolphin emulator blog as well. The last one: https://dolphin-emu.org/blog/2019/02/01/dolphin-progress-report-dec-20… I remember vaguely something about them using a visual difference tool as a regression test, really cool!

Somewhat related: I'm always thoroughly impressed with how complicated and knowledgeable the people who work on these topics are. I don't even use the product, but I love reading the Dolphin blog [0] because they write about fairly complicated topics in a way that's pretty approachable, and it always makes me appreciate how much I don't know about these topics. While I feel like it would be difficult-but-not-impossible to be a contributor to say, the linux kernel (this is probably me grossly oversimplifying the process), I think I could spend the next year diving into graphics programming and basic hardware topics and still not contribute in any meaningful way to a project like Dolphin. Articles like this and the Dolphin blog definitely make me realize how much I don't know. 0: https://dolphin-emu.org/blog/

One of the best talks at Siggraph last year was on Bungie's particle system Destiny 2 (slides are here: http://advances.realtimerendering.com/s2017/index.html). The talk was an elegant breakdown of how they (1) created a CPU interpreter for a domain specific language describing particle parameters, (2) ported it to the GPU (even running an interpreter on the GPU for parts of the production game!), and (3) how they converted it into a compiler for the obvious performance wins. Apparently running bytecode interpreters on the GPU is not uncommon: https://dolphin-emu.org/blog/2017/07/30/ubershaders/

If you haven't heard about this project before, their monthly progress reports are great examples of tackling technical matters in simple terms. Here's one from May https://dolphin-emu.org/blog/2017/06/03/dolphin-progress-report-may-20…

You can verify for yourself if you have time; the reports themselves are an excellent resource both for their content itself and as an example to learn from: https://hn.algolia.com/?query=dolphin-emu%20comments>0&sort=byD… https://news.ycombinator.com/item?id=15381844 >kanwisher: Always interesting to read the release notes on this product. They go into such technical detail, its a joy to read >overcast: This comment is becoming the HN equivalent of "First!" on Dolphin Progress Reports. https://dolphin-emu.org/blog/2017/10/02/dolphin-progress-report-septem…

The sibling post linked here - "Emulating Dragon Quest X Online" - is also a good read: https://dolphin-emu.org/blog/2017/08/23/emulating-dqx-online/

In the embedded case, usually only vendors have (or used to have, who knows if they use source control) the source code. As I said, you have no idea how bad it is unless you've had to work with that crap. Maybe have a look at "Bad" in this classic. https://www.dolphin-emu.org/blog/2013/09/26/dolphin-emulator-and-openg… Edit: right, you can backport fixes and features while keeping the ABI stable. That is what Google seems to be doing with Android kernels to some degree.

I agree that this is an excellent way to write release notes; The only project that does better in my opinion is Dolphin: https://dolphin-emu.org/blog/

Yes, they remind me of the people behind the dolphin emulator. They are working to make old games better than they've been on the original console. For example they added support - to have 60fps in games that had only 30fps on the console, - to load custom high definition textures, - to play games at higher resolutions (1080p and beyond vs 720p) and - to have stereoscopy in games. And that without access to source code, mind you! Their work is amazing. Source and recommended read: https://dolphin-emu.org/blog/series

If you follow the (extremely well written) monthly progress updates on the blog, Dolphin has been seeing speedups in the range of 100% per month in some of the past few months. Pretty incredible. https://dolphin-emu.org/blog/

The write-up by the Dolphin team is also worth reading: https://dolphin-emu.org/blog/2013/09/26/dolphin-emulator-and-opengl-dr…

CPUs are getting faster. Sandy Bridge is a 15-20% IPC improvement on Nehalem for some heavily integer and memory access based workloads. On the same workloads, Haswell is another 15-20% IPC improvement on Sandy Bridge. I work on the Dolphin Emulator (https://dolphin-emu.org/) which is a very CPU intensive program (emulates a 730MHz PowerPC core, plus a GPU, plus a DSP, all of that in realtime). We try and track CPU improvements to provide our users with proper recommandations on what hardware to go for. Here are the results of a CPU benchmark based on our software: https://docs.google.com/spreadsheet/ccc?key=0AunYlOAfGABxdFQ0UzJyTFAxb…

Please note that the article currently links to the old Dolphin website. We have moved to http://dolphin-emu.org/ Sadly we do not control the old domain. A mistake made long ago. Google indexing is hard to beat! (I'm sorry these sentences do not flow well...)

You're very welcome. Computer graphics has a very interesting history, and like many things, there's a lot to learn from studying it. Surprisingly, many techniques and principles are still relevant to this day. Thankfully, the Internet is full of documentation, post-mortem accounts and reference implementations to learn more about all this. Here's a bunch of random noteworthy things and references I forgot to link (sorry for potentially digging rabbit holes): The best information tends to come from official documentation detailing almost everything you want to know about the inner workings of systems. Additionally, unofficial community documentation can also be of great quality and complement official sources. The architecture overview posts from Rodrigo Copetti (https://www.copetti.org/writings/consoles/) pack a lot of accurate information at a glance, and are a great starting point if a specific topic piques your interest. The Resident Evil 2 microcode post-mortem: https://ultra64.ca/files/other/Game-Developer-Magazine/GDM_September_2… Improved lighting, reverberation, Dolby surround and MP3 microcodes from Rare: https://youtu.be/jcIupBUAy98?t=41 H.264 decoding microcode: https://www.reddit.com/r/n64/comments/gpwxx0/my_dragons_lair_port_now_… The Reality Signal Processor's programming guide:…

I completely agree, but as someone who's owned publishing for changelogs on large-ish, often super technical OSS projects, it can be very difficult to explain some of the concepts needed to grok a bugfix or low-level design change even in the span of a couple paragraphs. And more importantly, that context needs to be written by the engineer involved in the change, which means more context == less code work. That being said, I think some projects do it extremely well. My gold standard for a while has actually been the OSS Dolphin emulator for Gamecube/Wii. They write incredible progress reports[1] every 1-2 months that give phenomenal context on how they found the bug, why it matters, how it works, and what they did to fix it. Another great example is VS Code[2]. Their context tends to be around changes that are more UX-oriented, but it's still a great way to understand what new value you're getting on every new release. [1]: https://dolphin-emu.org/blog/2022/02/08/dolphin-progress-report-nov-an… [2]: https://code.visualstudio.com/updates/v1_67

Dolphin Emulator https://dolphin-emu.org/

> Triforce games can support two types of cards for saving: Magnetic Cards (magcards) and Integrated Circuit (IC) cards. Magcards are cheaper, fragile, and can only survive so many writes before failing. They have the added bonus of having a printable side, where the game can print a player's achievements and more. IC cards are more like old credit cards with a thicker plastic. They weren't printable, but were much sturdier. Source with photos: https://dolphin-emu.org/blog/2026/02/16/rise-of-the-triforce/#type-1-t…

PS2 floating-point behavior is one of the few hardware misfeatures so awful it affects emulation of competing systems[0]. The game True Crime: New York City is so dependent on PS2 floating point that the GameCube port installs an error handler just to make 1/0 = 0. Which isn't even PS2 hardware behavior. But it is "close enough" that the game does not immediately throw you into the void every time you step on a physics object. [0] https://dolphin-emu.org/blog/2021/11/13/dolphin-progress-report-septem…