Piracy is prohibited Warez/downloading games talk is prohibited. This includes asking for system files, ROMs, encryption keys, etc.
+
+
+
Do not link or discuss unofficial builds. Citra does not provide support for unofficial builds. They may introduce new bugs, contain GPL violations, or be a virus.
Does Citra support network connectivity or online play? Yes, Citra supports networked local WiFi, but does not support connecting to Nintendo’s servers.
+
+
+
Are you planning to make an Android version? Yes, and it’s available now!
Developing an emulator for a modern, complex system like the Nintendo 3DS requires significant hard work and dedication from a large team of developers. We will never charge you for Citra and will always make our source code freely available. We do not make any money from our work, however development has many expenses that are often paid out-of-pocket by our team members, among them:
+
+
3DS consoles to explore and reverse-engineer the hardware
+
3DS games for testing, reverse-engineering, and implementing new features
+
Web hosting and infrastructure setup
+
Software licenses
+
Additional hardware (e.g. 3D monitors to eventually support 3D output, GPUs as-needed to improve rendering support, other peripherals to add support for, etc.)
+
+
Your generous donation will go directly toward providing these to our team. Previous donations have already been used to purchase several 3DS consoles, games, and host our current website! However, our costs will continue as our team grows, our website grows, and we strive to achieve high game compatibility with Citra.
The nightly build of Citra contains already reviewed and tested features. If you require support with the installation
+or use of Citra, or you want to report bugs you should use this version. This version is still in development, so
+expect crashes and bugs.
+
The Canary build of Citra is the same as our nightly builds, with additional features that are still waiting on review
+before making it into the official Citra builds. We will not provide support for issues found only in this version. If
+you believe you’ve found a bug, please retest on our nightly builds. This version is still in development, so expect
+crashes and bugs.
+
+
+The Citra updater provides a easy interface to install, update and manage Citra. Unless you know what you are doing,
+ this is likely what you are looking for.
+
+
+
+Autodetected platform: XYZ
+
+
+ Unknown platform - Citra is only supported on 64-bit versions of Windows, macOS, Linux, and Android 8 (Oreo) or above.
+ If you are running one of these, choose one of the options below.
+
Pokémon X / Y and Many More Games Are Finally Working!
+
You’ve been asking for it for years now, and we’ve been listening, we promise!
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The Pokémon league awaits your challenge!
+
+
+
+
+
+
Thanks to the hard work of one of our very talented developers, some of Citra’s longest standing issues are finally fixed! Special thanks to all those who are supporting these efforts on Patreon. These donations are given directly to support the hardworking developers such as wwylele who spent almost an entire year of his spare time on the feature in this blog post! We love working on this project, and have a whole lot more to talk about in the coming weeks!
+
It’s been a long time in development, but we are finally pleased to announce that many of the oldest bugs in Citra are now fixed in the latest Canary build thanks to the tireless efforts of wwylele.
+Among the titles that had issues with Citra’s HLE audio emulation, one stands out as the number one most requested game of all time: Pokémon X and Y.
+Before we get too much into the long story behind this great achievement, we should set expectations for what this means for the users of the emulator.
+
F.A.Q
+
+
What games are now working?
+
+
We’ve been able to test a few of the fan favorites such as Pokémon X / Y, Fire Emblem Fates and Echoes, and many more! If you’ve experienced audio crashes or bugs in the past, now’s the best time to try those games out again and help us find any issues with this new accurate audio feature.
+
+
How can I test it out?
+
+
In the Audio tab of the Configuration menu, there is a new option for Emulation. Selecting “LLE (Accurate)” will use the new feature, while the default value “HLE (Fast)” will continue to use the original audio code.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ You can find the dropdown here. Keep in mind you cannot switch between Fast and Accurate while a game is running
+
+
+
+
+
+
+
Why is it so slow on every game?
+
+
We still recommend using HLE (Fast) Audio emulation until further speed improvements are added to LLE (Accurate) emulation! Today we are pleased to announce that many bugs are fixed, but we are also aware that LLE (Accurate) audio makes every game run at around 5FPS or less!
+
As you’ll see in the rest of the article, this feature has been in development by a single developer for almost a whole year now. During this time, the focus was on accurate emulation, but now that it’s released, we can and will put effort into optimizing it.
+
+
What will happen to the current fast audio emulation?
+
+
It’s not going anywhere! In fact, thanks to this new accurate audio emulation option, it should help developers make it even better so it will work with every game.
+
+
How long will it take for games to be full speed with Accurate Audio?
+
+
We can’t ever say for sure, but we really hope that it’ll be soon! We’ve done some preliminary profiling and can confidently say that there’s plenty of room for improvement, but now that the code change is live, we welcome any and all contributions to the Teakra project.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ With the level up freeze fixed, Citra has levelled up too!
+
+
+
+
+
+
With that out of the way, buckle up as it’s now time to dive into the storied history behind the fix for Citra’s most prolific bug yet!
+
All About HLE Audio And Why It’s Awesome
+
Take a trip down memory lane, and you’ll dig up a blog post from 2016 titled “HLE Audio Comes to Citra”.
+Written by the very talented MerryMage, High Level Audio Emulation (or HLE audio for short) provides excellent audio quality while also being very efficient.
+So for emulation, where the goal of many developers is not only to make the emulation accurate, but also to make it fast, HLE audio is a great middle ground as you get to have high accuracy while also taking almost no processing effort.
+But as usual, there is one thing that’s particularly hard to get right with HLE audio.
+In order to write an effective HLE audio engine, one must first reverse engineer the audio code that the game uses, and truly understand what it does.
+
merry spent a long time writing tools to help break down exactly what the game was doing, and also decipher what the audio code is doing semantically.
+This turns out to be pretty tricky in practice.
+It’s much simpler to look at disassembly and see what the code is doing than it is to really understand why it’s doing something, which is a requirement when recreating the audio code.
+Simply put, writing HLE audio support means diving deep into how the code for the game’s audio works, and recreating its functionality in Citra, without ever running any actual audio code from the game.
+But there’s a very different way to handle audio, and this is hinted about at the end of the 2016 article: Low Level Audio Emulation (or LLE for short).
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Fire Emblem Echoes: Shadows of Valentia can get past the intro now as well
+
+
+
+
+
+
Debugging Pokémon X Told Us That It’s Broken but not WHY
+
Before looking in depth at what LLE audio emulation is all about, a quick diversion into the debugging effort that went into Pokémon X / Y is in order.
+Looking at the Citra YouTube channel, one will find several videos talking about the games’ progress!
+At the time, we were just as excited as everyone else to see how well the games were advancing, but at some point, they stopped getting better.
+After CRO support landed to get the games running (thanks to both Subv and wwylele), several fixes to the 3DS GPU emulation, followed by geometry shader support (thanks to the hard work of neobrain, JayFoxRox, ds84182, and once again wwylele), we really hoped that the games would finally start working!
+But as everyone knows, they still didn’t work!
+
We kept feeding more and more time into features that made the emulation so much better, yet this one very popular and very stubborn game would not work.
+Subv spent many long hours reverse engineering the game, and found that at the core of the game lay a state machine that drives the game engine.
+The game would transition from state to state, and, mysteriously, whenever the game softlocked, it simply wasn’t moving onto the next state.
+As cool as it is to learn what causes the softlock, it doesn’t answer the big question of why the game doesn’t transition to the next state like it should.
+After spending more time than anyone could have asked, eventually he burned out and moved on to develop other amazing features for Citra such as multiplayer network support, leaving us without any more clues to why the game freezes.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Kirby Battle Royale’s missing sounds have been found!
+
+
+
+
+
+
Then Is the Problem Everyone’s Best Guess: AAC Audio?
+
Well-informed users have pointed out for years that the specific sounds that are not playing in Citra when emulating Pokémon X all have a very suspicious thing in common: all of them are stored in AAC audio format.
+AAC (or Advanced Audio Coding) is a standard audio format that typically has better sounding audio than mp3 at the same bitrate.
+While we appreciate the detective work, there was one glaring problem with deciding that we just needed to add AAC audio support.
+How does one add AAC audio support to Citra’s HLE audio?
+
The answer was talked about earlier: in order to add a new feature in HLE audio, one needs to reverse engineer the audio code that the games use, and then find out exactly how the audio code processes AAC audio; where the data is passed through, where each decoding option is stored, and all the way down to what every bit of data written to the audio pipe semantically means.
+To make matters worse, there’s no guarantee that this will fix any other games with similar symptoms.
+After all, a game can upload any code it wants to the audio chip, meaning even if they both used AAC audio, they could potentially use different decoding options, causing the HLE AAC decoder to work for one game and not the other.
+And worst of all, it’s possible that everyone is wrong, and X/Y are freezing because of a completely unrelated issue!
+
Faced with this dilemma, wwylele designed a test to show that audio is likely the cause of the softlock.
+He knew from the get go that the HLE audio code was based off reverse engineering the most common audio code that games use, the home menu, and decided to make a custom rom hack for Pokémon X that replaced its audio code with the home menu audio.
+Upon launching the game on a 3DS, everything seemed fine at first, but soon enough the familiar lack of background music kicked in, and Pokémon X started to behave exactly like it does in Citra.
+One short level up later, and the game froze, just like in Citra!
+We double-checked the results by recreating this on different copies of Pokémon X and different 3DSes, and it all went the exact same way.
+Audio issues were very likely the cause, but what then should be the fix?
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Detective Pikachu cutscenes no longer skip parts and now run at the proper speed
+
+
+
+
+
+
The Long Road to LLE Audio Emulation
+
The methods for fixing any audio issues boil down to two potential solutions.
+Either take a good amount of time to research, reverse engineer, and recreate the audio code for Pokémon X/Y in HLE, or build out a program that can read the original binary audio code in Pokémon X/Y and emulate the actual audio chip, known as LLE.
+Both of the options have advantages and disadvantages.
+HLE means it’ll be faster overall to get working, but also will likely take a lot more time and effort to fix bugs in other games with slightly different audio code; whereas with LLE, potentially all audio code in every game will just work, but it also will take a lot longer to write, involve even more detailed technical research, and scariest of all, will probably end up running much slower.
+Weighing the risks and rewards, wwylele ended up choosing to build out a full LLE audio emulator, what’s now known as Teakra.
+
The first commit on Teakra started in late January 2018, but the design and research phase started before this.
+The audio chip in the 3DS, the TeakLite, was a part of the DSi system as well, albeit only used by a very small number of DSiWare titles.
+In spite of its limited use on the DSi, GBATek is loaded with valuable information about the processor, put together by the reverse engineering efforts of Martin Korth and many other contributors.
+There are others who have worked hard to write documentation, which wwylele referenced often throughout development.
+
Building an LLE audio emulator from scratch is an exciting, yet somewhat scary prospect.
+When working on HLE audio emulation, you really start to understand what the games are doing, but when writing an LLE audio emulator, you create a magical black box where binary data goes in, and binary data comes out.
+This was especially true for wwylele because he had never worked with a DSP before this!
+It’s daunting to know that you’ll gain a deep understanding of the architecture and the instruction set of the audio chip, but you won’t gain any detailed knowledge of how the audio code is functioning.
+
+
+
Who knew live streaming yourself staring at a monitor for hours could be this fun!
+
+
Wait, How Long Until This Starts Playing Sound?
+
Several months after starting, the interpreter was coming along nicely, and it was time to start hooking things together.
+As a quick explanation about what the interpreter is, the interpreter is responsible for running the actual machine code of the audio code, and emulating each of the instructions on the computer that it’s running on.
+This marked another very exciting yet very scary point in time; it had been about 5 months of work on audio emulation, and all of it in complete silence!
+To understand why, first one must understand that audio hardware is rather complicated, and it’s more than just running the machine code.
+Anything beyond simple audio output is typically generated through specialized hardware known as a Digital Signal Processor, or DSP for short.
+This custom built hardware is very efficient at transforming and processing audio samples while using less power than the CPU would, enabling the game developers to produce high quality audio without severely impacting battery life.
+
In order to start seeing results, wwylele needed to emulate the ways that the 3DS communicates with the DSP chip, such as Memory Mapped IO, hardware interrupts, and Direct Memory Access.
+The first two are a piece of cake to recreate compared to DMA.
+There are straightforward test cases one can write and run on a real 3DS to verify how the 3DS and TeakLite DSP communicate and recreate this in Teakra, and after a month of work, wwylele got them both functional.
+But DMA poses a unique challenge, as DMA enables the DSP to do direct memory to memory transfers, independent of what the CPU is doing, making it really hard to figure out how it works!
+To add to the trouble, DMA is the least documented feature on GBATek, meaning there is nothing one can study to get an understanding of how the TeakLite does DMA transfers.
+
Maybe, just maybe, DMA wouldn’t be needed to produce audio output!
+Around August 2018, wwylele hooked everything together except for DMA with this hope in mind and…
+
Nothing.
+
Even worse, the games exhibited the same behavior as before HLE audio was added to Citra, implying that the games weren’t detecting that anything was working at all.
+After spending a few weeks fiddling around with the code, and trying to rule out that it wasn’t playing audio because of some bug in the existing code, wwylele reaffirmed what he always knew.
+When it comes to writing an LLE DSP emulator, it’s all or nothing.
+Either all of your code works, or absolutely nothing happens.
+Time to work on DMA.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ A small sample of what it looks like when you are trying to understand all of this DSP stuff
+
Over the next month and into September, wwylele took shots in the dark and tried to implement DMA.
+He started first with a simple approach to copy data to and from the specific memory regions.
+DMA allows the DSP to copy data quickly both to and from the 3DS RAM, making it well suited for uploading audio samples and writing audio output.
+With this simple approach in place, data was being transferred into the emulated DSP, but the output was always zero.
+Debug the code as he might, it was just too frustrating to figure out what was wrong.
+Was there an error in the interpreter? MMIO? Audio output? Maybe it was actually in DMA?
+At this point, the stress was too much to handle.
+The fear of failure after spending so much time and effort on this project really sunk in, and wwylele just stopped working on Teakra.
+By the middle of September, wwylele had just had enough, and decided to work on something else in the meantime.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ It turns out developers are still just regular human beings. Thankfully everything turned out okay!
+
+
+
+
+
+
Success… Finally!
+
The end of November rolls around with no news about DSP LLE, and wwylele is working tirelessly to fix many other core issues, including fixing issues with how Citra handled memory that prevented many cheat codes from working properly (but more on that in another blog post!)
+Out of nowhere, there’s new progress on DMA.
+wwylele worked out some extra details about the different patterns that the DMA can use to copy memory, and things started taking off from there.
+The next day, he noticed an oversight in his simple DMA approach, which ended up causing the DMA to copy data to the program region in memory instead of the data region!
+Now that data was going to the right spot, it was much easier to debug.
+
After some more reverse engineering and hardware testing, wwylele had a good idea of how to recreate DMA completely, and tried it out on a custom application that just produces a simple sine wave.
+
+
+
After some more tinkering, and with renewed enthusiasm, he started finding and fixing minor bugs here and there.
+All of a sudden, everything just started working.
+
+
+
And with a few more fixes…
+
+
+
Finally, on Dec 6th, this is what happened after we hooked it into Citra’s audio framework (sped up to full speed.)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The audio used to be too loud after changing to certain armor in Monster Hunter Generations, but this bug is no more!
+
+
+
+
+
+
The Future of Audio in Citra
+
So what is going to happen to the current audio code?
+As you can see, there’s a lot of benefit in both approaches, and we feel they both have a bright future ahead of them.
+HLE audio will almost always remain the preferred choice for users, as it’s much faster and produces very good audio quality, while LLE audio will be an excellent tool for finding and debugging audio issues, as after any last remaining bugs are worked out, it should have near perfect compatibility.
+With LLE audio released now, we can use it to take a deeper look at the communication between 3DS and DSP, allowing us to mimic responses from the DSP, and begin researching what each of the bytes of data actually mean.
+We plan to fix any outstanding issues with HLE “fast” audio to support all of the games, and also plan to optimize LLE “accurate” audio so it will be usable at a good framerate!
+
+
+Thanks to our Patreon supporters, our fans, and our userbase for the continual support!
+
Please consider supporting us on Patreon!
+If you would like to contribute to this project, checkout our GitHub!
Sometimes it’s hard to wait. We’ve noticed that users are very excited about the future of Citra, which means wanting
+to try all of the changes all of the time.
+But, emulator development can be a slow, arduous process as new changes can bring big regressions and problems with
+the much wanted new features.
+
In order to satiate the needs of our users, we’ll be adding new builds for download: bleeding edge builds!
+These builds will contain experimental features and changes designed to give the absolute fastest builds with the most
+features combined into one download!
+Since these releases are official, unlike other random builds you might find on the internet, there is no chance that
+they will contain a virus, or anything else that can potentially be harmful.
+
Because updates will come at a rapid pace and there is a chance of these changes adversely affecting emulation, the
+builds will let you know when a newer version is available and auto-update if you allow it.
+
You can download the bleeding edge development builds at our downloads page right now!
+While Windows is the only operating system targeted at this time, the other operating systems will follow shortly.
+
While these builds aren’t technically supported, they can be extremely useful for catching regressions and other issues
+from the various experimental features rolled into them.
+If you experience a bug, please make sure that the latest nightly builds do not have the issue before reporting it.
Hello there emulation aficionados!
+Today we are unveiling the most requested addition for Citra: Android Support!
+That’s right, you can finally play 3DS games on the go!
+
Users and Devs - A Tale of Perspectives!
+
Citra has great game compatibility and performance (provided you have the hardware), cross-platform support, multiplayer support, and much more.
+But ever since Citra Desktop achieved a stable state, the most requested feature has been something entirely unrelated to the core emulation.
+
Users began requesting a portable version of it.
+Being an emulator for the 3DS, a handheld console, they wanted something they could carry everywhere and play games anywhere, and it came in the form of an Android app.
+During the glory days of Citra development, users would ask almost daily if we had an Android app or if we planned to make one.
+This had become such a frequent occurence that we had to add it to our Discord server FAQ.
+Do you plan on making an Android app? No, not at this moment.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Discord FAQ (Old vs. New)
+
+
+
+
+
+
From the users’ perspective, it seemed as if the devs disliked the idea of an Android app.
+But for the developers, it was just the abundance of many other features and improvements that took higher priority.
+And given the huge amount of effort for an Android version, we simply did not have enough time for it.
+
Changing Times and Changing Priorities
+
This was all back in 2016~17.
+Fast forward to 2018 and suddenly there it was!
+SachinVin, a developer then outside of the core team, worked hard to port Citra to Android and finally the first iteration of a mobile app was released.
+
While it granted users their long awaited request, it suffered from quite a lot of performance issues.
+This led to an increase in support and feature requests of the official team - who had nothing to do with that unoffical Android port.
+So while the team applauded the efforts of this developer, we had to deny providing support for it because it was unofficial.
+
However, what users didn’t know was that due to rising demand for an official Android app, members of our developer team had been working on an Android version themselves.
+To reduce redundant work, we invited SachinVin to collaborate, bringing us closer to an official Android release.
+
History of Citra - Design Decisions
+
From the very beginning, Citra was developed with cross-platform compatibility in mind.
+We have always supported all three major OS platforms - Windows, macOS, and Linux - but that’s not all.
+If you took a look at a Citra build folder for Windows, you’d find two executables citra.exe and citra-qt.exe(which also caused a lot of confusion for a while).
+
This is because, Citra supports two interfaces:
+
+
A basic CLI (command line interface) powered by SDL.
+
A fully featured GUI (graphical user interface) powered by Qt.
+
+
In this way, developers can ensure that UI elements are decoupled from the core, so that new frontends can be implemented.
+This separation of code logic for core emulation and UI elements paved the way for a smoother development process for Android.
+But it wasn’t an easy journey.
+
Development
+
For almost a year, bunnei has helmed this development effort and has pulled other developers into working on this.
+He figured that since nobody in the core team had any experience with Android development, someone had to start things off somewhere.
+Development started as a basic app with the frontend based off of Dolphin’s Android app.
+SachinVin added initial OpenGL ES support.
+Then we added the core components of Citra to the app, and games were booting and playable!
+
But it still had many bugs and issues: the settings weren’t saving, the button overlay was clipped, there were multiple layout issues, graphical issues, and much more.
+Android being a diverse OS, each fix had to be extensively tested on a plethora of devices to make sure it didn’t break anything else.
+jroweboy also started optimizing many areas of the code to bring in multiple small performance gains, which added up to a large performance improvement.
While this was going on, SachinVin was working on implementing an ARM64 backend for Dynarmic.
+Dynarmic is Citra’s Just-in-Time (JIT) CPU compiler, which is used to emulate the ARM CPU in Citra.
+While many Android devices also use the ARM architecture, there are complications that arise when you try to run unmodified instructions from a 3DS game.
+So we have to recompile the code on the fly, with our CPU JIT, to make them work on Android.
+Thanks to SachinVin’s work, performance received a huge boost.
+
Mobile CPUs aren’t even remotely as powerful as desktop CPUs, so we needed to take full advantage of their multiple cores.
+That was why we ported over a feature - Async GPU emulation - from our sister project, yuzu.
+GPU emulation is now done on a separate core, significantly improving performance.
+
The work that started as a basic app soon shifted gears and turned into a full blown effort to release a user-ready Android port.
+We then started looking closely at its usability and began improving the UI/UX.
+A few of the settings available on the desktop version didn’t apply to the Android version.
+And since we were trying to improve usability, we revamped the settings menu to keep things simple.
+Flamboyant Ham helped ensure that the UI met certain accessibility standards, and designed the new controller overlay — thus helped add support for all the 3DS buttons.
All of this development work finally paid off and we had a performant app.
+However, just when we thought we could release an alpha version, another unofficial Android port appeared!
+It came as a shock to us when we found that this port had taken some leaked changes from our Android development branch (such as our JIT backend and graphical fixes), added further hacks, and did not exactly comply with the GPL.
+Users began flooding our forums and Discord asking why we hadn’t released an official port, when an unofficial one was performing great.
+
Despite these hardships, our progress was not hindered.
+Having previously dealt with the nuisance of modified “custom” builds, we were concerned about how easily our changes would just be incorporated into other unofficial builds, without upstreaming any new improvements, if the source was made public prior to the app release.
+Thus the team became even stricter.
+They worked behind-the-scenes and slowly but surely implemented missing functionality, fixed bugs, improved performance, and (most importantly) polished the app UI for a smooth and hassle-free user experience.
+
Fast forward to February 2020, after taking a hiatus to work on yuzu, bunnei reignited the flames and development picked up pace again.
+Anticipating the desire for gamepad support, bunnei decided to implement the feature.
+Users who dislike touchscreen controls can rejoice!
+Technically, almost all gamepads should work, but if your gamepad doesn’t work with the app, please reach out to us on our Discord server.
+
BreadFish64 contributed various OpenGL ES improvements and fixed many graphical glitches we had been experiencing.
+He also added support for motion controls, recursive folder scanning, installed title detection, texture filtering, and made some general improvements to the app.
+Motion control support works by leveraging the gyroscopes that exist in almost every modern Android device.
+
+
+
+
+
+
+
+
+
+
+
+
+ I’m using tilt controls!
+
+
+
+
+
+
FearlessTobi, who has been well known for taking both the time and effort to ensure changes from Dolphin and yuzu are upstreamed to Citra, ported many changes and fixes to the Android frontend from Dolphin upstream.
+He added support for Amiibo files, translations, and the microphone (if your Android device has one).
+This improves compatibility with the few games (like WarioWare Gold) that use the 3DS microphone.
+Furthermore, he cleaned up the codebase, removing a lot of unused stuff, and proceeded to fix various bugs related to the themes, gamelist, UI, games database, and more.
+
zhaowenlan1779, who originally implemented camera support, the software keyboard applet, multiplayer fixes, and many more improvements to Citra Desktop, expressed his interest in the Android development.
+He added native camera support, implemented the software keyboard applet and a Mii Selector in the Android app.
+Thanks to his work, Citra Android can now utilize the camera on your device, or images saved to your phone, for scanning QR codes and more.
+And, the software keyboard applet will enable users to input text with the Android keyboard app on Citra when playing games that need it.
+He also implemented a Mii Selector for the Android app, making it easier to use your Miis, and improved Tobi’s microphone support.
+
weihuoya, a first-time contributor and the developer behind the second unofficial port, implemented AAC decoding support for Android.
+If you recall, AAC decoding was the culprit behind many games crashing on Citra e.g. Pokémon X/Y.
+He implemented native AAC decoding using the MediaNDK library that comes bundled with Android.
+He also made a few changes to Citra Desktop that translated to performance gains in the Android version.
+
Here are a few screenshots of various games running on the app:
SachinVin for originally repurposing the Dolphin UI, adding initial OpenGL ES support, and implementing most of the Aarch64 dynarmic backend.
+
Tobi for Amiibo support, Mic support, translations, bug fixes, porting frontend changes from Dolphin upstream, and more.
+
weihuoya for implementing AAC decoding for Android
+
zhaowenlan1779 for the software keyboard applet and camera support implementation.
+
+
Many recent improvements to Citra Desktop were also motivated by the Android release, including Disk Shader Caching, Proper Texture Format Reinterpretation, Splitting Frame Presentation and Emulation into separate threads and more.
+In the near future, we will try to bring feature parity between the desktop version and the Android app.
+Throughout the development process, many of the challenges presented by the port were tough eggs to crack.
+All these obstacles finally paid off and we now have an app that we consider a release candidate.
+
What Works and What Doesn’t?
+
The app is still in beta.
+So, while we have tried to squash the bugs we’ve come across, you may still run into the occasional glitch.
+If you run into any major problems, please report them to us on our Discord server or forum and we will try to organise them.
+
The app requires a minimum of 64-bit Android 8 (Oreo), and OpenGL ES 3.2 support.
+These are relatively high requirements; however, they allow us to ensure that every device that can run Citra will have a reasonably good experience.
+As for hardware, we recommend a device with a Snapdragon 835 or better.
+Your experience may vary greatly depending on the quality of your device’s GPU drivers.
+
+
+
+
+
+
+
+
+
+
+ Pokémon on an older device
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Pokémon on a newer device
+
+
+
+
+
+
Fin
+
You can grab the app now on the Google Play Store.
+
+
The app is free, but we would appreciate it if you contributed to our Android development and server upkeep funds by becoming a Patron or upgrading Citra Android to Premium!
+With that, you’ll get Dark Mode support, Texture Filtering, and perhaps some future features.
+Most importantly, you’ll be supporting the developers and allowing them to continue working hard on the Android version of Citra.
Networked Multiplayer is one of those features that was so surprising to see, that the lucky few chosen to test it were wondering if it was real. For the past year, several developers have banded together to bring this amazing implementation of online play to Citra.
+
+
The Nintendo 3DS heavily relies on wireless for its slew of multiplayer compatible titles. Considering that so many games feel empty without their multiplayer features, we’re excited to announce that in select titles, you’ll be able to play together with your friends across the world in the latest Canary builds of Citra!
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Let’s Battle!
+
+
+
+
+
+
Bringing Multiplayer to Citra
+
Emulating 3DS local wireless and bringing it to Citra was a huge endeavor shared by subv, B3N30, jroweboy, and JayFoxRox. It went through several stages of development, from actually reverse-engineering how wireless worked in games, to implementing those features in Citra, and then implementing an infrastructure so that even casual users could easily take advantage of this feature.
+
This emulates the 3DS’ ability to do local wireless multiplayer. As such, it doesn’t rely on Nintendo’s server and does not require a Nintendo Network ID. While on a real 3DS you’d be limited to the people in your immediate vicinity, Citra boasts a complex server/client infrastructure that forwards a game’s wireless communication across the internet.
+
Unlike single console netplay used in most emulators, users won’t have to worry about desyncs, synchronizing saves, or any other issues typical of netplay. Each user is using their instance of Citra as a unique emulated 3DS that is communicating with everyone else through that particular server.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Join your friends!
+
+
+
+
+
+
Currently, servers created in Citra can hold up to 16 players. High player counts should be avoided for now due to bandwidth issues. In this initial release, each connected Citra instance sends raw packets to the host (or server) and the server then forwards those packets to every single client. As such, with each player added, the bandwidth requirements increase greatly.
+
While hundreds of games support wireless connectivity, compatibility is limited in the initial release. Tons of titles were tested, but only a handful came up as working properly. Note games may handle latency differently and your experience may vary.
+
The Server Browser
+
In order to get together with other players, you’re going to have to join the same room with Citra’s server browser. Creating and joining servers is extremely easy in Citra and can be done in just a few clicks. If you’re a verified user, you can create a public game through the traversal server for people to join. These public games can be seen by anyone on the server browser, but you are also able to put a password on publicly listed games. Remember to port forward, otherwise your friends won’t be able to connect!
+
Unverified users aren’t left without options, though - they still have the ability to create unlisted games, direct connecting, and can join any hosted server.
+
Do note that verified users will have their privileges revoked for violating any site policies while on the server chatroom. Please respect the recommended game listed in publicly hosted games, as even unrelated games will add to the bandwidth load.
+
Wireless Compatibility
+
Works Like a Charm
+
Super Smash Bros. for 3DS
+
Super Smash Brother’s local wireless play works perfectly in Citra for up to four players. Because the game expects all players to be running in lockstep, users will need to maintain similar framerates for a stable connection. Some stages, such as the pictochat stage, can run full speed even on moderately powerful computers.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 1v1 me fox only no items final destination
+
+
+
+
+
+
Pokémon X/Y, Pokémon Omega Ruby/Alpha Sapphire, and Pokémon Sun/Moon
+
Almost everything works perfectly in the Pokémon games. The only thing that fails is adding friends - so try to stay away from that. Users can battle, trade, and watch passerbys as they show up or leave on the local wireless server.
+
Because of compatibility issues in general with X and Y, using wireless support may be problematic for those two titles.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Challenge your friends in beautifully upscaled Pokémon battles!
+
+
+
+
+
+
New Super Mario Bros. 2
+
New Super Mario Bros. 2 runs perfectly, and our testers were able to play together multiple worlds into the game flawlessly. Users on the same server can search for partners and join up just fine.
+
+
+
+
+
+
+
+
+
+
+ Your princess is in another castle? Save her together!
+
+
+
+
+
+
Functional But Flawed
+
Luigi’s Mansion: Dark Moon
+
This title has perfectly functional wireless support for trying to tackle the “Scarescraper”! Unfortunately, the game is so demanding that getting a fun experience out of it is near impossible.
The Monster Hunter games are extremely demanding in Citra, but wireless support does somewhat work. A second player can join a game, share quests and trade guild cards. But, the game supports up to four local players on console, and anything more than two causes disconnections in Citra.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Go out and hunt with all your friends! … as long as that number is only 2.
+
+
+
+
+
+
Incompatible
+
For various reasons, the following games were tested and do not work. Also note that Download Play and Spotpass titles do not work due to limitations in what Citra currently emulates.
+
+
Mario Party Island Tour
+
Mario Party Star Rush
+
The Legend of Zelda: TriForce Heroes
+
Mario Kart 7
+
Tetris Ultimate
+
Code of Princess
+
Sonic Generations
+
Asphalt Assault 3D
+
Ridge Racer 3D
+
Monster Hunter Generations
+
Monster Hunter X
+
Monster Hunter XX
+
Street Fighter IV
+
Kirby Triple Deluxe
+
Dragon Quest Monsters: Terry’s Wonderland 3D
+
Resident Evil: The Mercenaries 3D
+
Dragon Quest Monsters: Joker 3 Professional
+
F1 2011
+
Kirby Fighters Deluxe
+
Planet Crashers
+
+
Going Forward
+
After the months of work put into making Networked Multiplayer a reality, we’re excited to see it finally brought into the public eye. While only a handful of games work in this initial release, we’re hoping to bring support to more titles in the future, as well as optimizing the netcode for lower bandwidth usage, and allowing for even bigger user hosted servers.
It’s finally happening folks: The Citra Team would like to announce that we now have a project-wide Patreon. This will be a way for you, our users, to donate directly to the Citra developers, in support of their efforts to continue to make Citra the best option available to enjoy 3DS games. Patreon will be yet another way for our biggest fans to contribute to the project.
This is something that has been requested by users for several years now. However, the Citra Team has been a bit apprehensive. In the past, we have had some concerns about how a Patreon might be distributed among the developers. We’ve also been concerned that the idea of profiting from emulation may taint the free and open source spirit of Citra. We would like to be crystal clear: Citra will always be free and completely open source, and we have no plans to use Patreon to put our project behind any form of paywall.
+
However, there have been a few emulator teams that have had very successful Patreons in recent years, and users have seen these projects make tremendous progress. Naturally, many such users have asked the question, “How much further progress could Citra make if they had a Patreon?”
+
While we do not know the exact answer to this question, after some careful consideration, we’ve decided that a Patreon is a good move for Citra. Our developers dedicate hundreds (and sometimes thousands) of hours to the project purely out of passion for emulation and software development. However, this is not sustainable, as our developers also have to balance time between real life, work and school. We, as a team, believe that having a Patreon will both motivate (and eventually enable) our developers to work even harder on Citra.
+
We believe that we’ve come up with a plan to fairly share the Patreon among the core members of our team. Furthermore, as a team, we are all firm in our commitment to ensure that Patreon will only be used to incentivize open source development, and not to charge users for Citra.
+
How will Citra’s Patreon work?
+
Citra will have a project-wide Patreon – there will be a single way to donate and contribute to the entire team. Donations to this Patreon will be shared evenly among the core members of the Citra Team (this includes developers, but also may include our most active administrators and writers). Core membership will be established based on a combination of tenure and activity. We want to ensure that our long time contributors are rewarded, but also that there is room for our newer “heavy-hitting” developers to be part of this.
+
Thanks for reading, and we hope that you support us in this endeavor!
Hey there, Citra fans!
+It’s been a few months since our Android version released and its reception has been absolutely wonderful.
+We wanted to take this opportunity to make an announcement and answer a few questions many of you have had.
+
App Installs
+
Citra Android has now reached 500,000+ installs on the Google Play Store!
+
This is an absolutely incredible achievement and your enthusiasm is a big factor in what drives development of the app.
+Thank you all for your support!
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Incredible!
+
+
+
+
+
+
Save States Announcement
+
At the time of release, we said that we would put our efforts into bringing feature parity between the desktop and Android versions.
+We have now released around a dozen updates in the past few months, with each one bringing us closer to that goal.
+Today is no different, we are happy to announce another update to Citra Android featuring support for Save States.
+Thanks to zhaowenlan1779, you can now easily farm those shinies in your favourite Pokémon games or create quicksaves right before the toughest bosses, all on your mobile phone!
Reminder: Do not rely on Save States entirely. Remember to create normal saves occasionally to prevent loss of progress in the event the save state becomes corrupt or incompatible with a future version of Citra.
+
+
+
+
+
+
+
+
+
+
+ Save states, on mobile!?
+
+
+
+
+
+
Additional Questions
+
We would also like to address any concerns regarding a slowdown in development on Citra Android.
+
Due to the nature of the Google Play Store, we are only able to release updates when enough improvement warrants a new release. Google seems to arbitrarily reject our updates and this has caused weeks of delays in the past, but we’re doing our best to work around these issues and push out builds that have new features, improved stability, and better performance.
+
Citra Android also greatly benefits from most improvements to the Desktop version of Citra. We are actively looking for a dedicated Android developer to step up and focus on Android specific improvments, but in the meantime, our developers are doing the best they can to eventually reach feature parity with the Desktop version.
+
We appreciate your continued support and patience. An emulator without a community to enjoy it is a sad sight, so we are ecstatic that we have such an incredible community surrounding Citra.
+
We hope you continue to enjoy Citra, whether it’s on your PC or Android device, and can’t wait to bring future improvements to you all!
While Citra was first founded in April of 2014, visible progress for the emulator didn’t really happen until the turn
+of the year. After a long struggle to get anything to boot, 2015 saw Citra evolve from an experimental emulator that
+couldn’t run games into an experimental emulator that can run games. And while it may not seem like Citra is that far
+along, it is truly amazing how much things have progressed in just a year since the first commercial title booted.
+
However, with Citra’s success and high visibility within the emulation community, it may be easy to think that we’ve
+gotten this far on our own, but that would be quite misguided. Citra would not exist without the work that others
+have done before and alongside it: Particularly the folks behind 3dmoo
+(Normmatt, ichfly, and plutoo),
+who did a lot of the early reverse-engineering to boot commercial games; as well as those who have worked tirelessly
+to break open the 3DS and share their work publically
+(yellows8, Bond697,
+fincs, among many others), and smea for providing a public
+way to run (and a library to create) homebrew.
+We’ve been lucky to be part of a much larger community of hackers, developers and researchers that have always been
+willing to lend a hand in some way, which is something that many other emulator teams are not quite as fortunate
+to have!
+
Like most young projects, Citra didn’t have a great website infrastructure featuring a blog last year; there was no
+need to as it didn’t boot games or have a big fanbase interested in its development. It was just one of several
+emulators that had promise. With that promise starting to be fulfilled and a shiny new blog ready and waiting, let us
+look back at the year that Citra rose above the rest and became THE 3DS emulator.
+
Winter: The First Retail Games
+
In late 2014, Citra was a very small project developed primarily by bunnei and
+neobrain. The heart and soul behind the effort to get a game rendering was their
+reverse-engineering skills put into figuring out how the 3DS GPU worked and accurately represented it in an accuracy
+focused software renderer. Meanwhile, bunnei assisted with that while figuring out how
+to recreate the environment that the 3DS games run in, with a particular focus on emulating the 3DS’ operating system.
+Because they focused on accurate emulation, parts of the emulator were fairly advanced despite no commercial games
+booting.
+
Until one day…
+
+
+
+
+
+
+
+
+
+
+Recognize the game? That’s The Legend of Zelda: Ocarina of Time 3D rendering on Citra on
+December 13, 2014. This distorted upside-down Triforce
+loading icon was the first rendering of a commercial title in Citra. After that, Ocarina of Time 3D would promptly
+hang, but even this little blip caused excitement from the developers. To get a retail game to show any graphics at
+all – be it a simple icon or a complex 3D scene – requires that a virtual environment be created that is sufficiently
+complete such that from the perspective of a game, it is running on an actual Nintendo 3DS. This isn’t just a matter
+of being able to execute the game’s native machine code, but also provide it with enough of the essential features it
+expects when running on a real 3DS. For example, 3DS games run within a full operating system (much like your PC or
+smart phone), that of which Citra needed to duplicate.
+
Propelled by this breakthrough, neobrain and bunnei worked
+tirelessly day and night to push Ocarina of Time just a little bit further. With bunnei
+focused on fixing core emulation bugs and implementing necessary OS features, neobrain
+continued with GPU reverse-engineering based on the features that Ocarina of Time was lacking within the software
+renderer. While it took months to get the game booting, getting it to the title screen only took a few more days. The
+result of this hard work may look like nothing but a screenshot from a glitchy emulator, but when it happened it was a
+huge cause for celebration: Citra’s first fully 3D-rendered scene.
+
+
+
+
+
+
+
+
+
+
+
This breakthrough only motivated developers further. With a 3D rendered scene under its belt, users had taken notice
+and news of Citra had spread. This fervor was met with more than just hype, but also results. It was only a matter of
+weeks before several more retail games were booting in Citra, some of which were able to be played in-game. It became
+a sort of friendly competition among the developers to see who could be the first to get a new game booting it. Among
+the next few games to fall were Cave Story and Cave Story 3D, VVVVVV, Ikachan, Gunman Clive, Super Little Acorns, and
+Retro City Rampage.
+
+
+
+
+
+
+
+
While this was cause for excitement, there is a pattern to be noticed in the games that booted. Most of the titles were
+either simple 2D games, or ports from other systems. This actually has some meaning: ports and simple games are less
+likely to use new features of a system than say a blockbuster title from Nintendo designed for the system to show off
+what it can really do.
+
In the next part, we’ll continue our 2015 retrospective
+with Spring. By then, Citra fever was in full effect, with new devs and old faces showing up to throw their hat in the
+ring and see who could make the next big breakthrough. No one was ready for how much could change in just three more
+months.
This month we bring you the second installment of our two-part progress report on Citra in 2015! With this part, we
+discuss the evolution from Citra being able to barely run a few commercial games at a few frames-per-second, to where
+it is in 2016: Running many retail games at reasonable speeds, some of which are fully playable with near flawless
+graphics! We discuss Citra’s new “dyncom” CPU core, the OpenGL renderer, per-pixel lighting, and various bug fixes.
+Lastly, we wrap up with an outlook for 2016, and a special thanks to everyone who has helped make Citra what it is
+today!
+
Spring 2015: A New CPU, Renderer and More
+
The arms race to get games booting ran into a wall. Often, testing games and getting to crash points would be incredibly
+painful because of how slow the emulator ran. Instead of measuring frames-per-second, testers often referred to
+seconds-per-frame. Donkey Kong Country Returns 3D would sometimes require three realtime seconds to render a single
+in-game frame in the software renderer! It took over 90 minutes to capture all of the footage for a three minute video
+of Super Monkey Ball 3D!
+
+
+
+
+
+
Within the next few months, bunnei and Lioncash replaced
+the old “ARMULATOR” CPU core in Citra with a better implementation that was both several times faster and much more
+accurate. Despite the fact that it was still an interpreter, this new core was still efficient enough that the
+performance implications were huge. With this new core, games that were light on graphics could reach above half-speed
+on very strong processors.
+
Shortly thereafter, a new developer joined the Citra team – tfarley – with the ambitious
+goal of implementing a hardware renderer using OpenGL. Up until this point, Citra had used a software renderer
+primarily developed by neobrain to render graphics. While a software renderer is great
+for development and achieving pixel-perfect accuracy, Citra’s GPU emulation had become the major performance
+bottleneck. Even with infinitely fast CPU emulation, the software renderer was so slow that no games would run full
+speed despite this.
+
While the rest of the team continued with other development efforts, tfarley went on a
+month-long battle developing this new OpenGL renderer. All of this resulted in Ocarina of Time 3D running nearly
+perfect in Citra using OpenGL while running at a fairly decent speed! Below is a very early video of Ocarina of Time,
+before the renderer was completed and merged into CItra’s mainline repository.
+
+
+
+
+
+
Summer: More Accuracy, More Performance
+
With the summer, development slowed down a bit – but several additional improvements were made. By this point, the
+team had already made lots of incremental advances in 3DS emulation, resulting in a significant number of retail games
+booting, such as Super Mario 3D Land, Fire Emblem: Awakening, The Legend of Zelda: A Link Between Worlds, Mario Kart 7,
+and many more.
+But there was still one major issue that was blocking many games: video playback. 3DS games use a proprietary format
+known as “MOFLEX” to play video clips, which are commonly used for intro logos, cut scenes, and more. Not only was the
+video format unknown, but any time a MOFLEX video was used, Citra would hang in an infinite loop for unknown reasons.
+However, this issue proved to be no match for our team – within a matter of weeks, Citra developers
+yuriks and Subv reverse-engineered and implemented all of the
+mechanisms necessary to prevent hanging and play MOFLEX videos!
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Bravely Default’s intro sequence relies on MOFLEX video support
+
+
+
+
+
+
With many games now running stable with fairly accurate rendering, it became evident that with a bit more speed some
+titles would not only be playable in Citra, but enjoyable to play. On top of this, more speed would make testing even
+easier, so with a huge library of games now working, the task again came to making things faster.
+
The cause of the slowdown was very obvious: Citra’s emulation of 3DS vertex shaders. With emulators like Dolphin and
+PPSSPP, your GPU uses shaders to emulate the target system’s GPU, which does not actually use any shaders of its own.
+The 3DS, on the other hand, has a more modern GPU that natively supports its own shaders – which are not as trivial to
+emulate in the same manner. The approach that we took was similar to CPU emulation – and we were using a pure
+interpreter for the job. As such, the solution was pretty obvious; Even a naively implemented Just-In-Time (JIT)
+compiler would make our shader emulation scream. With that in mind, bunnei set out to
+implement a vertex shader JIT.
+
While it took several weeks to develop, the difference in speed was very obvious. Vertex heavy games were sometimes two
+or three times as fast, allowing some games like Ocarina of Time 3D to near full speed in many areas!
+
+
+
+
+
+
Autumn: Closing out the Year with a Bang!
+
After a brief summer hiatus, development on Citra began to pick up again with autumn 2015. While Citra now had a
+library of games running without severe problems, many still relied on more advanced graphics features that had yet
+to be reverse-engineered. One of these more widely used features is fragment lighting – a feature that enables complex
+lighting calculations to be performed on a per-pixel basis. A major breakthrough was made when hacker and homebrew
+developer fincs made major strides in figuring out the 3DS fragment lighting implementation. Immediately,
+bunnei began embodying this work into Citra.
+
+
+
+
+
+
+
+
+
+
+ An early fragment lighting demo running in Citra
+
+
+
+
+
+
Despite that it’s not a fully complete implementation of fragment lighting, the results have significantly improved
+Citra’s visuals!
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ It’s a super moon!
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ With fragment lighting implemented, the moon became even scarier! H-hurray?
+
+
+
+
+
+
While no more major features were merged into Citra by the turn of the year, Subv came up
+with one final teaser of things to come before letting 2015 come to a close. CROs, the dynamically linked libraries of
+the 3DS (similiar to DLLs on Windows), blocked several very popular 3DS games from booting in Citra, such as Pokemon
+X, Y, Omega Ruby, Alpha Sapphire and Super Smash Bros. for 3DS. While the implementation was far from done, it still
+was able to boot up some of the games that relied heavily on this feature.
+
+
+
+
+
+
Citra in 2016
+
With 2016 already upon us, it’s shaping up to be a pretty exciting year for Citra! In addition to the many tasks
+discussed in the 2015 progress reports that are still ongoing, we’ve got several exciting new features to look forward
+to:
+
+
MerryMage has been making some exciting progress on an HLE implementation of the DSP,
+meaning audio support may come sooner than expected!
+
tfarley has been working on a HW renderer optimization - “texture forwarding” - that
+minimizes copies of textures/framebuffers to/from emulated RAM. The result of this effort will be both a performance
+improvement as well as support for upscaled rendering!
+
yuriks has plans to rewrite the vertex shader JIT to fix several inherent flaws, which
+will improve accuracy and address the crashing issues, as well as improved memory and IPC emulation in the kernel
+HLE.
+
Subv is still looking into CRO support, as well as mipmapping and scissor testing.
+
ds84182 is currently working on an implementation of Pica’s geometry shaders.
+
bunnei has plans to work on Circle Pad Pro (required for getting Majora’s Mask in game),
+CROs, and a JIT compiler for faster CPU emulation.
+
Lioncash has plans to continue working on ARM11 CPU emulation, improving both accuracy
+and performance.
+
+
With all of these exciting new features upcoming, it’s quite possible that 2016 might be the year that Citra becomes
+official with a v1.0 release!
Welcome to the first Citra Progress Report of 2016! While 2015 will be considered the year that Citra first played
+games, 2016 is quickly shaping up as a year filled with higher compatibility, greater stability and much more as Citra
+matures. The avalanche of new features from tons of contributors has made it hard to keep up with everything even for
+developers!
+
Because there have been so many changes and there are so many different games, it can be very hard to keep up with what
+is working and what is not. To try and make things a little easier, we’ve compiled some of the biggest changes of the
+new year together to show you just how far Citra has come already!
Immediate Mode Vertex Submission is a second way for the PICA200 (aka the 3DS GPU) to draw vertices. Unlike the normal
+method, Immediate Mode trades off some efficiency when drawing complex models for less overhead on each object. This
+makes it a suitable option for things such as UI elements. Despite all of that, it’s capable of being used for just
+about anything, and some games use it for drawing all of their graphics.
+
ds84182 first implemented the feature and showed just how many games it could fix. After
+it was merged, some issues were found and yuriks fixed some edge cases and added support
+for vertex restart. Vertex Restart is a feature necessary when drawing using triangle strips, in order to break apart
+consecutive strips.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Etrian Odyssey IV running in Citra with Immediate Mode Vertex Submission
+
+
+
+
+
+
With this, along with previous fixes of #1462 and
+#1624 for correct depth writing behaviors, Etrian Odyssey IV and other
+games appear to be playable in Citra.
Due to the different way Windows reports filenames to programs compared to Linux or OS X, Citra was previously unable
+to load any files with a path containing non-English characters. That is, if your file was named using accented
+letters, Chinese, Japanese characters, emoji, or in general any characters not present in the
+ASCII character set, Citra would be unable to find the file! Considering Citra
+is developed and used by people around the world, this was a very important issue. We did not want people to need to
+rename files or directories to be able to open them with Citra.
+
LFsWang took the time to fix the frontend code so that Citra was able to correctly load
+these files. More recently further improvements were made so that this
+works correctly even if you’re loading files with characters from a language different than the one running on your
+operating system.
MAD and MADI (Multiply-Add and Multiply-Add Inverted, respectively.) are shader instructions in the PICA200 GPU, handled
+by Citra’s shader JIT and interpreter. These instructions execute a multiplication followed by an addition
+(d = a × b + c) in the same instruction. They’re unique in that they’re the only instructions that works with
+3 source operands, and thus have a special way of being encoded into the program. Citra interpreted this format
+incorrectly, causing it to sometimes operate on the wrong values!
+
Handling these instructions correctly, much like a CPU emulator, is paramount for accurate emulation. In this case, it
+happened that these instructions were commonly used in font rendering shaders, and this bug often manifested as
+gibberish textures and incorrect positioning, as can be seen in this The Legend of Zelda: A Link Between Worlds
+screenshot:
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The Hylian language just seems to get harder and harder to read every game! Oh… wait.
+
+
+
+
+
+
Considering that emulators over a decade older than Citra are still finding problems with how CPU instructions are
+handled, it’s no surprise that our shaders aren’t bullet-proof yet either. There should be many, many games affected
+by the encoding fixes, so if you’ve been seeing gibberish text or other problems, there’s a fair chance that this
+change could have fixed the bug.
Vertex Attributes are an integral step in rendering. They can tell the GPU the bone weight, color, position, etc. So
+when JayFoxRox discovered that the Vertex Attributes were misaligned and pulling the
+incorrect values, he knew he stumbled upon a major problem. One game in particular affected by this was Super Smash
+Bros. 4, which since the MAD/MADI fixes had been displaying some graphics, although things looked pretty messed up.
+
+
+
+
+
+
+
+
+
+
+ Pikachu has seen better days.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ While lighting is a bit off, the game looks fairly playable!
+
+
+
+
+
+
With this fix, the Super Smash Bros. 4 actually looks fairly playable! The align attributes fixes should also fix other
+games where the graphics tend to explode like Super Smash Bros. 4.
One of the more notable problems that Citra has currently is that many games require a savefile extracted from the 3DS
+in order to get in game. This is due to many reasons, including partial or incorrect file system and OS emulation.
+Because getting saves from newer games can be problematic due to encryption (and it’s generally a pain anyway), getting
+Citra to create and load savegames properly is a very important task that will continue to be a priority for the
+forseeable future.
+
The save fixes recently merged mostly have to do with formatting the cartridge saves correctly. 3DS titles are very
+picky about how their saves are formatted and will often fail if all of the files aren’t handled exactly like they
+want. This was the reason why Mario Kart 7 would hang in Citra! And once you’re in game, it is quite the visual treat
+for a 3DS title!
+
+
+
+
+
+
+
+
+
+
+ Mario Kart 7 is now fully playable in Citra and looking better than ever!
+
+
+
+
+
+
The above change fixes Mario Kart 7, Final Fantasy Explorers, Lego Batman 3: Beyond Gotham, The Amazing Spiderman, and
+likely many others games that previously hung while creating or deleting savefiles.
Citra’s GPU shader JIT had a bit of a flaw: It would keep previously compiled shaders in memory forever. Furthermore,
+it only allocated a fixed amount of space for all compiled shader code. When testing the early games that booted on
+Citra, none of this seemed to matter and things continued fine. But, as Citra has been running more complex games and
+was being used by more users for longer periods of time, it became apparent that this simply wasn’t good enough. Games
+were managing to fill up the fixed amount of space that Citra had allocated for the Shader JIT Cache and crashing the
+emulator!
+
bunnei added a simple fix to the memory management which allows Citra to drop old, unused
+shaders in order to free up space for new ones being requested by the game, fixing these crashes and allowing for
+longer game sessions. For example, Kirby: Triple Deluxe is now stable in Citra, even when using the Shader JIT:
While most of the issues with the shader JIT were fixed with the aforemoentioned changes, there remained a fundamental
+flaw with how flow control was handled. Previously, the shader JIT inlined CALL and JMP instructions. This had several
+issues: 1) Inlining all subroutines resulted in bloated shaders being generated, and 2) jumping to arbitrary addresses
+(and nested jumps) couldn’t be supported. This is because when inlining code, the same source shader code might be
+recompiled multiple times. To support arbitrary jumps, there needed to be a one-to-one mapping of source code to
+compiled code.
+
To fix this, bunnei refactored the shader JIT to do a multiple step compile: First,
+analyze the shader and identify subroutines, jumps, and return locations. Next, compile the code (just once), and
+insert additional code to handle the returns and jumps. In addition to enabling arbitrary CALL/JMP instructions, this
+results in pretty constant compiled shader sizes of around 40kb, which significantly reduced the memory footprint of
+the shader JIT.
+
This change fixes IronFall: Invasion, Pokemon: Rumble Blast, and several other games:
We’d like to mention the amazing work done by MerryMage to bring proper DSP HLE and
+audio support to Citra. Over the past few months, she has been carefully chipping away at figuring out how audio 3DS
+works, removing several hacks in Citra along the way. While many of her efforts have been transparent to users up
+until this point, they have laid the groundwork for soon-to-come audio support. With changes
+#1386, #1403,
+#1441, #1566, and
+#1572, we’re now closer than ever to hearing games for the first time
+in Citra! While MerryMage has audio nearly complete in unofficial branches, there are
+still a few remaining issues before it gets merged.
+
Contributors of 2016
+
We’ve got a fortunate problem to have: It’s often too difficult to mention every contribution made to Citra when
+writing progress reports! We’d like to extend a special thanks
+to all that helped advance Citra further
+since our last progress report, you guys rock!
2017 has been an amazing year, with more work having been put into the project
+than ever before, but it’s not over yet! Last we met was
+June, and just two months later the
+Citra issue tracker is brimming with
+lots of changes once more. I am extremely excited for this month (and what’s coming
+up the next few months) but we’re getting ahead of ourselves! On this progress
+report, let’s check out the big fish in the July and August pond of patches!
Citra has two main rendering backends, software and OpenGL, but until very
+recently, no one gave much attention to the software backend. The OpenGL backend
+is faster, makes better use of the GPU, and allows things such as texture forwarding
+for higher resolution rendering. But there is one thing on which the OpenGL backend
+falls flat on its face—accuracy.
+
However, wwylele has just revived the software
+renderer (inspired by an attempt Subv made prior),
+adding almost all of the features the hardware renderer had received over the years.
+In fact, every addition to the hardware renderer has been given an equivalent
+in software:
Despite the software backend being incredibly slow, it is important to have a
+complete software implementation of the 3DS’ GPU so that Citra can be used as a
+stable, working, and complete reference implementation in the future, when
+obtaining a working real console may be much more difficult.
Citra emulates the 3DS system services at a high level of emulation, or HLE for
+short. What this means is that every time a 3DS application or game running in
+Citra makes a request to the 3DS System Software, Citra captures the request and
+tries to translate it into its PC equivalent, rather then running the 3DS System
+Software directly.
+
For example, if a game makes a call to FS:OpenFile,
+Citra in turn calls the operating system’s file opening function
+(_wfopen_s() on Windows,
+or open() on macOS and Linux),
+with the path to the virtual SD card added to the beginning.
+
Now, on top of the usual names for files and folders, there’s two special folders
+inside every single folder on your computer, . and ... These aren’t actual
+folders in the sense that you can place files and other folders inside of them.
+Instead, they each symbolize the current folder, and the folder one level above
+it, respectively. For example, C:/Windows/System32/.. actually means C:/Windows/.
+
With this in mind, a few Citra developers believed a game could, in theory, chain
+multiple ..s together to get to a file they weren’t supposed to know even existed,
+like /../../../../Documents/IMPORTANT.docx. Citra would then ask the operating
+system to open the file %AppData%/Citra/sdmc/../../../../Documents/IMPORTANT.docx,
+which actually means that it would open C:/Users/Anodium/Documents/IMPORTANT.docx!
+
Before you suggest that Citra simply ignore .., a game can use it for legitimate
+purposes. And if it were to use it, it would most likely crash, as the resulting
+file path wouldn’t exist.
+
This was already handled for most file functions in Citra, opening, reading,
+writing, etc. except for a few things, like renaming a file. In this case, the
+malicious game could just ask Citra to change /../../../../Documents/IMPORTANT.docx’s
+name to /delicious_secrets.docx, effectively moving IMPORTANT.docx into Citra’s
+virtual SD card! From there, the game could just ask Citra to open
+/delicious_secrets.docx to read the file it was originally forbidden from accessing.
+
This patch now fixes this, such that if any 3DS game or application tries to do
+exploit the rename file function from inside Citra, rather than doing what it asks,
+Citra gives them ERROR_INVALID_PATH, which most games interpret by crashing. So
+far, we haven’t found any real 3DS software that tries to do this, but at least
+now future attempts to do so are blocked.
+
Do note though, that most of us are not security experts, and even for those who are,
+harderning the software is much more difficult and much less worthwhile than actually
+having an accurate 3DS emulation. The surface area of an emulation project is huge,
+and so writing malicious code intending to exploit one is not too difficult in any case.
+
But at the same time, malware authors generally target either the largest populations,
+or the most lucrative populations, and emulation is neither. And for the effort
+required to do so, most will only toy with the idea in their head, or maybe write
+a proof-of-concept for fun, rather than genuine malicious intent.
The 3DS GPU has a data transfer mode called TextureCopy, which as the name says,
+is for copying textures but with a configurable gap in case the texture is going
+to be copied into a smaller resolution area. This mode is enabled by setting the
+3rd flag in the GPU and causes it to ignore every other flag except the 2nd, which
+is used to tell it whether or not to crop the texture.
+
This is nice because it can be used as a quick and easy way for 3DS developers to
+duplicate textures, and can be used in situations such as the one pictured running
+on hardware in Pokémon Super Mystery Dungeon below. But when it came to running
+something that took advantage of this feature in Citra, it didn’t always work the
+same as it would on console.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ How jagged
+
+
+
+
+
+
Fortunately (and to much rejoicing!) wwylele stepped into the ring to wrestle with
+this issue. They prepared a test program
+to help gain an understanding of how the hardware handles the TextureCopy operation
+in comparison to Citra. After the hard work of doing the research was out of the
+way, wwylele implemented it in Citra.
Ubuntu Linux 14.04 is the de-facto standard desktop Linux distribution. It’s also
+old. Very old.
+So old, in fact, that the compiler it ships with can’t compile Citra. And our
+buildbot, Travis CI, that automatically compiles and
+builds Citra from source, just so happens to use Ubuntu 14.04 VMs. :(
+
Formerly, we would update the compiler from a third-party repository before compiling
+Citra itself. This also had the side-effect of updating the standard library that
+comes with the compiler, as each compiler version is inextricably tied to the same
+version of library by design. Unfortunately, a recent update to the library was
+incompatible with a large majority of systems because it’s too new for Ubuntu 14.04,
+breaking the Linux build once again.
+
Now, rather than building Citra directly inside Travis, a
+Docker container is started that’s running Ubuntu 16.04
+instead, which is much more well supported (and yes, it can compile Citra out of the box!).
Kloen has put the time and work into Citra’s Qt
+frontend to make it themeable. Now users can enjoy a dark mode and other custom
+colour schemes, just by editing a CSS stylesheet!
This does not eliminate the need for dumping a shared font from a legitimate system.
+
This in itself isn’t an extremely visible or perceivable change from a user
+perspective, but it is something that helps us take another stride towards
+accurately recreating the way the 3DS actually operates. All system data is
+uniformly stored in the system archive now that the system font can be included
+with it. Citra does still fall back to the deprecated shared_font.bin file if
+it was dumped before, for compatibility’s sake. 3dsutil has been updated to be
+able to dump everything as a system archive, so that Citra may be able to work
+with it in a way that’s more accurate to the actual hardware!
+
And Everyone Else
+
Just because your work wasn’t written on here doesn’t mean it’s not as important!
+Every little bit counts, every pull request inches the project one step closer
+down the long road of accurately emulating the Nintendo 3DS. So I would like to
+give my thanks to everyone who’s contributed
+these past two months, for giving us those extra metres down this road.
The summer of 2017 has just rolled in, and although we don’t have a summer of code, the patches continue rolling in regardless. We’ve got a ton of fixes this month in the renderer, so this report is going to be very screenshot heavy. With that out of the way, let’s get right to it.
+
There is a rarely used feature in the 3DS’ GPU called procedural textures, “proctex” for short. It allows games to generate new textures on the fly by just plugging in a few parameters. Mario & Luigi: Paper Jam, and Kirby: Planet Robobot both use it to generate realistic sea surfaces. The formula behind proctex had to be reverse-engineered in order to be implemented, which fortunately fincs did and documented. Using this documentation, wwylele simply translated it into code, and dropped it into Citra, fixing both those games.
To calculate lighting on any given object, the 3DS’ GPU interpolates the light quaternion with the surface quaternion of that object. There are three main methods to doing so, the linear interpolation (lerp), the quadratic linear interpolation (qlerp), and the spherical linear interpolation (slerp). All this time Citra used a lerp, which, although the fastest, can lead to a lot of distortion when interpolating across a large rotation angle.
+
yuriks researched and implemented slerp on Citra, and after a long while of work, it turns out that the 3DS uses lerp as well! The bug in Citra was caused by not normalizing the quaternions before interpolating them, which greatly affected the results. This particular issue sent them down a very deep rabbit hole, only to lead to a red herring. But, at least it was (eventually) fixed!
The Citra disassembler and debugger was planned to be a fully-featured debugger for 3DS programs, as how Dolphin, No$GBA, or other emulators have done. Unfortunately, they were never given the care that was needed to get them up to speed, and so it was extremely buggy, disassembling code to complete nonsense at times. Not to mention that it was missing a lot of essential features, such as setting breakpoints. All of these things, combined with the fact that we already have added 3DS support to gdb, it just made sense to get rid of this one and focus on the other.
The Circle Pad Pro was an accessory that added a secondary circle pad and ZL/ZR buttons to the old 3DS, years before the New 3DS was even annouced. It communicated with the 3DS via infrared, which allowed dropping the console into it directly without having to plug in any wires or modify the console. The New 3DS’ C-stick exposes itself to the system via a new, simpler (and incompatible) API, but for backwards compatibility, still exposes it via the infrared API, this allows games that were made years before the New 3DS to work perfectly well with the C-stick. These two additions give C-stick support to Citra, one through the C-stick API, and one through the infrared API.
For fragment lighting, the 3DS has a hardcoded Look-up Table of values to calculate things more quickly, but is relatively small, only 256 entries big. Because of this, for every time a lookup falls between two values, the game has a table, usually in the ROM, but it can be computed on the fly, that has the differences between the closest two values, called the delta table.
+
In Citra, to be more efficient, we give the LUT (look-up table) to OpenGL and tell it to filter it, much like how games on PC filter their textures to smooth out jagged edges, and thus doesn’t need to compute any differences at all anymore. Unfortunately, because we’re treating a table as essentially a 1-dimensional texture (since that’s the only concept OpenGL understands), we also need to deal with very big problem that the 3DS’ GPU and OpenGL both have different coordinate systems. Coordinate 0 on the 3DS refers the zeroth (i.e. the first, since it starts on 0) entry on the table, but in OpenGL, it means the left corner of the first pixel, which would instead be slightly less than the actual value of the first entry on the table because of the filtering.
+
As a workaround, some offsets were set on the table in OpenGL so that it would pick the correct entries. But, the LUT on the 3DS also has a mode called “two’s complement” in which each half of the table is “wrapped” virtually across past the beginning and end of the table, but not across the middle of the table. This completely messes up the table in OpenGL, leading to completely different results near the middle of the table, causing things like dark spots in highlighted areas.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Kyogre seems to have a bit of a skin blemish.
+
+
+
+
+
+
+
Although the OpenGL hack provided a slight increase in efficiency, in the end wwylele replaced it all with simply mimicking what the 3DS does, fixing the entire issue, and making lighting calculations significantly more accurate. Sometimes the simplest solution is the best solution.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Much better, guess the lighting got an acne treatment.
+
A lot of the questions we see on our Discord server all generally have the same answers; missing system or font files, missing config file, an incorrectly dumped game or cartridge, or simply not having modern enough hardware to run Citra. Because of this, TheKoopaKingdom has written a patch to auto-detect these problems, report them to the user, and link them to a guide that will help them fix it, all without human intervention!
For people with a lot of games, this new feature allows users to search through the entire list instead of having to browse. It works by checking to see if any games have any words the user typed in the search box. It’s a bit naïve as of this point, but at least there is something to improve now. Maybe you could help improve this?
3DS binaries all have an extended header (or ExHeader) that specifies certains things about the application such as what permissions it has to access system services, and what hardware memory can it access. Basically all titles only accessed and mapped memory in almost the same way; read-only access to video memory, and read+write access to two specific sections of the sound hardware.
+
Because of this, Citra used to simply ignore the ExHeader, give it the same map as every other title, and give it access to everything. But now, it will actually parse the ExHeader and map memory regions as specified. This is why ROMs created with braindump don’t work anymore, since braindump leaves the map empty, and Citra assumes that the title simply doesn’t need access to anything, making them crash or behave very strangely.
+
As a side-effect, yuriks also had to implement the entire memory map of the audio hardware, and took the opportunity to implement the New 3DS’ extended memory, which New 3DS exclusives like Xenoblade Chronicles 3D require. Although this doesn’t affect much in terms of game compatibility, Citra now emulates the kernel more accurately, and is now more prepared to handle exotic memory maps, like the ones used in system modules.
These new features are all just features that were not known or not researched enough when the original lighting implementation was written. A few small fixes lead to big changes, such as the fact that Super Smash Bros. for 3DS now has proper lighting, instead of colours looking washed out and very bright.
Recently jroweboy silently added a feature that allowed Citra to automatically refresh the game list when the game folder changes, so that restarting Citra was not necessary in order to see newly added games. The way this works is by creating a FileSystemWatcher for the configured game folder, and for every folder within it. This also means that if you were to set the games folder to something like, say, your home folder, Citra would become completely unresponsive while it created watchers for every single folder inside it. This little change adds a seperate thread that runs alongside the UI renderer, that searches the file tree, and when it’s done, it hands off the list of folders to the UI thread, which adds them all to a single watcher. Although this does still cause a tiny bit of unresponsiveness when adding all the folders to the watcher, it’s significantly less than it was before.
+
Contributors of June 2017
+
It has been absolutely amazing to see so much work be put in by people from all over the world, in ever-increasing rates. I never thought that we would get to the point where tripling the rate at which these reports are published would be warranted, but here we are. And though the work will only get harder, I absolutely welcome more people wanting to help make this the best emulator it can be.
+
Although this progress report was a bit bare than most, the majority of it was cut due to lots of changes being either internal or only a fraction of something much bigger. Nevertheless, stay tuned on our blog, our forums, our Twitter, and our Discord server for the next few months, as we have some very big™ things planned.
+
As always, thank you all very much for taking the time to work on Citra, and helping it become what is has, and will be.
In the last quarter, we’ve further improved the speed and accuracy of citra along with supporting more 3DS features, and we are very excited to show what we’ve been working on. It’s a bit hard to believe, but Citra is already three years old, and in these three years we’ve gone from an emulator that could barely run homebrew, to one that can run many commercially available games at playable speeds! It’s all thanks to the hard work of volunteers working to improve the emulator at a pace we could’ve only imagined back in the spring of 2014, and it seems 2017 shows no signs of slowing down.
Perhaps the most requested feature we’ve had on both the forums and Discord server has been gamepad support, and wwylele has delivered! Using SDL as the input backend, Citra now supports a huge variety of gamepads, including Xbox One, PS3, and PS4 controllers. In order to do this, they have completely rewritten the input handling architecture, replacing it with a much cleaner interface that will allow adding different input methods much more easily in the future.
+
For now, you can only configure your gamepad by manually editing a config file, but JayFoxRox has written a little tool to help edit the config file while we integrate it better into Citra’s UI. You can find the tool in the Citra forums here.
Citra’s video code has grown organically from the start; not much was known about the PICA200 (i.e., the 3DS GPU), so a lot of the backend for it was based on pure guesswork and the team’s past experience with working with emulation. It made a lot of assumptions on how it worked internally, which worked okay some of the time, but it was amazing at the time to even have a 3DS game load, let alone render a scene. So it was left alone.
+
The entire architecture of the 3DS was largely unknown, so development was done in small seperate bits at a time, and then trying to piece it all together into one cohesive piece of software. But, over time, as new pieces of information were found, the assumptions that were made previously broke. Some assumptions were very large, obvious, and easy to overcome, but a more subtle error that these assumptions created were not even in the design of the GPU, but rather the architecture and organization of the code itself.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Shouldn’t there be a bridge here?
+
+
+
+
+
+
The video code was very interconnected using this interface, so despite people being aware of this, it was also extremely difficult to move code around and reorganize it, as it could very easily affect unrelated bits of code that depended on it. This was only compounded by the hardware renderer, as it was written much like earlier, slowly adding hardware support bit-by-bit to separate parts of the video code, simply falling back into the software renderer when disabled or not supported.
+
There aren’t many changes visible on the surface here, but internally this rewrite of the video code that yuriks has been working on for the past few months has laid the foundation that Citra needs to be able to grow and mature in a clean and maintainable way. With these, things like geometry shaders (which many games heavily depend upon), more support for hardware renderers, and more accurate software renderers, could all be added with little to no effort besides the actual implementation.
+
Contributors of 2017
+
Despite only being early May, we’ve already made some great progress forward this year, especially so under the hood. The sheer majority of the work already done is not user-facing by any stretch, but it will definitely make it much easier for developers to contribute additional code and makes Citra significantly easier to maintain, which of course will lead to an even faster development cycle in the future. As always, thank you all very much for taking the time to work on Citra, and helping it become what is has, and will be.
New year, new changes in Citra. Specifically, lots of technical changes under
+the hood, from applets to IPC, have made Citra even more accurate and laid a
+foundation for even more goodies the next year. With many great changes all
+around, this article is going to be packed to the brim with all the new goodies
+that have come to Citra during those crimson months.
+
But, enough faffing about! Let’s get right into it:
One of the most requested features for Citra has been enlarging the window to
+cover the entirety of the screen. After almost a year of requests on both the
+Citra Discourse and Discord servers, Styleoshin
+has finally delivered!
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ No more pesky window décor!
+
+
+
+
+
+
Simply go into View → Fullscreen, or just strike the Alt + Return keycombo, and
+enjoy Citra to its fullest on your largest monitor.
The am service on a Nintendo 3DS handles the installation, tracking, and removal
+of applications and games installed on the console and SD card(s) via a centralized
+database in the NAND, with some parts of the database for SD card-installed titles
+on the SD card itself. It has a handful of nice features such as installing packages
+as they’re streamed in, along with DLC support being cleanly implemented as a
+side-effect of the CIA format’s design. CIAs themselves are also designed to be
+streamed in, which is used extensively across 3DS apps, such as the eShop streaming
+downloads directly into am so that it installs at the same time, or dlp using
+it to stream Download Play CIAs from one 3DS to another directly.
+
The CIA format starts off with a header that describes where each component of
+itself starts within the stream and a bitfield. This is then followed by a
+certificate signed by Nintendo, the CIA’s ticket, and the title metadata (or TMD
+for short). The TMD then contains a list of every CXI file the CIA could possibly
+have, along with their name, size, etc.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ A diagram of The Legend of Zelda: Ocarina of Time 3D’s CIA
+
+
+
+
+
+
The astute reader might’ve noticed I said that the TMD contains a list of every
+possible CXI. This is because a CIA might not contain every CXI for the game,
+such as in the case of DLC. The bitfield I mentioned in the header is used to list
+off which of the entries in the TMD actually exists within that CIA. This is
+(ab)used in some cases, such as the Home Menu Themes, in that every single theme
+that exists is actually a different CXI within the same CIA. Just tick the themes
+the user owns in the bitfield and then attach those CXIs at the end of it. Dead
+simple way for it to work perfectly with both streaming of the file, and making
+personalized CIAs for each eShop user.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ A tiny portion of the Home Menu Themes CIA
+
+
+
+
+
+
For the am side of streaming installations, the way it handles a request to
+install an application is by creating and then giving the requester a handle to
+a virtual file. This leaves most of the busy work to am, while the app only needs
+to worry about writing the CIA file into that handle.
+
shinyquagsire23 reimplemented the entirety
+of how Citra handles NCCH files, which quickly paved the way to implementing am
+in Citra. This allowed users to use FBI to install applications from its virtual
+SD card. He and BreadFish64 also went a step
+further and added support for installing CIAs via the SDL and Qt frontends
+directly, removing the need to use FBI. Do note that you cannot yet run installed
+applications and games directly, but CXI executables can access the virtual SD
+card for DLC, updates, etc.
Citra now has a fancy new installer and updater, thanks to j-selby
+and jroweboy’s efforts! If you haven’t already, we
+strongly recommend you download and install Citra through it, since it will make
+updating as easy as re-running the installer. You can check it out over here,
A little known feature in macOS is fat binaries, the ability to have the same executable
+contain binaries for multiple architectures. This was used extensively around 2007
+to support Mac OS X’s transition from PowerPC to x86_64, allowing developers to
+have one binary work on all Macs effortlessly.
+
After poking around Apple’s LLVM fork, MerryMage
+found that they had a specific flag to build binaries for Intel Haswell and later.
+Enabling it made a fat binary that contained both pre-Haswell and post-Haswell code,
+allowing Citra to take advantage of the newer CPU’s instructions, without dropping
+support for older ones.
When communicating with services, titles on a real Nintendo 3DS expect to wait some
+amount of time before the service replies or responds. Until now, Citra didn’t implement
+this, it responded without incrementing the virtual clock. From the emulated system’s
+perspective, it appeared as though services replied and responded literally instantly
+because of this, leading to strange side-effects.
+
For example, some buildings in Animal Crossing: New Leaf fail to render and
+cannot be interacted with.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Animal Crossing: New Leaf’s acting up
+
+
+
+
+
+
Or worse, some games such as Star Fox 3D can’t even
+reach the title screen.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ A demonstration of how instant service replies can break a title
+
+
+
+
+
+
The example in this figure is taken directly from Star Fox 3D. When the game boots,
+it checks if any save data exists on the console’s SD card, and tries to recreate it
+if it doesn’t. It does this by sending a request to the service responsible for
+file access, and then waiting for a reply. Because the request is synchronous,
+the thread that made the request is put to sleep and its priority lowered. The
+game actually uses this time that would otherwise be spent waiting by having other
+threads run while the original thread was still asleep, so that by the time it
+woke up with the response, it would have other resources it needed ready to go.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Animal Crossing: New Leaf, among other games, are now working perfectly with this change!
+
+
+
+
+
+
As Citra’s responses are instantaneous from the point-of-view of the game,
+the secondary thread doesn’t have nearly enough time to finish its job. And, the
+first thread’s priority comes back up above the secondary’s once it wakes up,
+this leads to the first thread waiting on the secondary thread to finish, but it
+never gets a chance to, due to its now much lower priority. Essentially, the
+first thread waits on the secondary forever, because the secondary never gets a
+chance to actually finish what it was doing.
+
ds84182 and Subv each
+wrote homebrew software which found and measured the issue, respectively, which
+B3n30 ran on a real Nintendo 3DS. With which, an
+average delay for every type of service reply was found. Then, Subv
+made Citra’s virtual clock increment by this amount before fulfilling any service
+request, solving many of the issues this brought.
As our previous section demonstrates, Citra’s virtual clock should be
+incremented before any time code that was supposed to be on a real
+Nintendo 3DS runs within Citra, including services. This change by MerryMage
+makes services increment the clock before they are called, instead of after.
+
+
One of the reasons this is important is that services can schedule calls to
+other services to run in the future. If the current time in the virtual clock is
+incorrect when the service schedule an event, it would run too early since
+the time for the scheduled event would effectively be shifted back by the virtual
+time it takes for the service that scheduled it would run.
+
Although this doesn’t fix any reported bugs, it does make the timing emulation
+of Citra much more accurate.
In Citra’s GUI, a strange bug exists, where if you have fullscreen enabled, and
+you start a game while the window is maximized, the window instead unmaximizes
+before starting the game. This was due to Citra not keeping track of the window’s
+state (be it normal, maximized, minimized, or fullscreen), and instead simply
+defaulting to normal. FearlessTobi found,
+reported,
+and fixed the bug. Citra now keeps track of the window’s state, position, and
+size, every time it goes fullscreen and restores them every time it leaves
+fullscreen.
In the input configuration menu, there has been the ability to change the key
+bindings on the keyboard for years now. Unfortunately, this menu allowed rebinding
+to keyboard keys only, not gamepads or any other input device one could use. This
+led to guides such as this one
+being written, to help users manually change the configuration files if they
+wanted to use gamepads with Citra.
+
This was extremely inconvenient and user-unfriendly to most, and so muemart
+took it upon themselves to finally add support for configuring gamepads within the
+configuration menu. Now, it’s as simple as clicking a button, and pressing the
+corresponding button on your controller, to set it up.
The shader JIT in Citra is a component of the video core responsible for
+recompiling GPU shaders for the 3DS to x86 code, so that they can be run on the
+user’s CPU directly.
+
Shader instructions like LG2 (calculate binary logarithm) and EX2 (calculate binary
+exponential) can be run potentially thousands of times per second in a typical
+Nintendo 3DS title, so it’s usually very worthwhile to try to optimize these as
+best as possible.
+
In doing so, MerryMage actually rewrote these two
+instructions to pure x86 assembly, and runs them inline with the rest of the instructions.
+A faster algorithm, combined with not having to deal with the overhead of calling
+an external library for math functions, led to this change almost halving the
+amount of time it takes to calculate these!
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Graph comparing times before and after this change
+
+
+
+
+
+
Conclusion
+
As always, changes big or small
+are vital to the project. Brick by brick, Citra will eventually be an accurate enough
+emulation of the Nintendo 3DS for most, if not all, uses. Thank you everyone for
+the hard work you’ve poured in.
Winter arrives once more, and like I mentioned in August’s progress report,
+I am extremely excited for what’s in store. In fact, many of the really big goodies
+I’ve decided to seperate to their own articles, which should be coming up in the
+next few weeks.
+
There’s also been many changes this month that improve the speed of emulation across
+the board, on top of the usual improvements in accuracy and features. And because
+of that, I’ve dubbed this month #Speedtember. Let’s dive right in.
+
+
Hello everyone! We’re all terribly sorry for the delay in getting this progress
+report out the door, but our main technical writer anodium,
+was just a bit busy surviving both Hurricane Irma and Maria. Although she’s a
+trooper and claims it’s not an excuse for the delay, we find that her personal
+safety is a tad more important. We’re all glad that she’s safe and sound, and in
+a state where she can keep pumping out quality articles for Citra!
Citra has a component called dynarmic,
+which recompiles ARM11 code to x86-64 code at run time, and then executes that
+generated code, rather than interpreting the ARM11 instructions directly.
+
Because the 3DS has a 32 bit address bus, it can address 2^32 unique memory locations.
+And because the 3DS can address data down to a byte, it can address up to 2^32
+unique bytes, or about 4 gigabytes of memory. When considering that no 3DS has ever
+been released with more than 256 megabytes of memory, this sounds absurd! And
+it is… unless you consider that a 3DS uses chunks of that huge address space to
+address peripherals, among other things. This is called memory-mapped input/output
+(MMIO), and is a great use of millions of addresses that would otherwise have
+been ignored, plus it also allows handling IO the exact same way memory is handled,
+so the design can be a bit simpler as it doesn’t need special circuitry to handle IO.
+
Herein lies our problem. Because that code is now being run on a PC, those MMIO
+devices don’t actually exist anymore, so Citra needs to handle those reads and
+writes itself. There’s a few ways to go about it, but the simplest and most naïve
+is to replace every memory read or write with a function that checks if that address
+is mapped to memory or IO. Unfortunately, this is extremely slow, and we can’t
+afford to have extremely slow address translation when games can access memory
+upwards of a few hundred thousand times per second.
+
With this, MerryMage has changed this behaviour so
+that rather than replacing a read/write with a function, it instead translates the
+address using a page table, and then tries to access that address directly. On the
+page table, all addresses that map to memory simply have a memory address written down.
+But on addresses that map to IO, it has address 0 written down. Trying to read or
+write to memory address 0 on x86 is illegal for every process except the
+operating system… and Citra tries to do it anyways!
+
When an invalid memory address (or a memory address that that process doesn’t have
+permission to access) is read from or written to, x86 CPUs throw a page fault exception.
+Citra takes advantage of this behaviour by also registering an exception handler
+for page faults. If a page fault is thrown, Citra knows the game tried to access IO,
+and thus recompiles the memory read/write to a direct call to Citra’s IO functions.
+This makes the usual case (memory access) extremely fast, and the less usual case
+slow, but only the first time it happens. Subsequent IO accesses use the recompiled
+functions which are faster.
+
This technique is called fastmem, and is not new at all. In fact, Dolphin uses
+it extensively in its JIT recompiler to speed up memory access as well. And thanks
+to MerryMage’s hard work, this same technique is
+now used extensively by Citra.
In order to support running multiple processes at the same time, like your computer,
+Citra implements virtual memory, in which each process has its own page table.
+The page table represents a translation from the process’ virtual addresses, to
+the 3DS’ physical (or “real”) addresses.
+
Before this, because Citra did not support multiple page tables, it also didn’t
+support running multiple processes at once, such as a game and the software keyboard
+applet. Now, thanks to Subv, Citra has an important
+building block in place.
Nintendo 3DS titles are contained within *.app files on the SD card or on the
+game cartridge, in the NCCH container format.
+This format is further divided into two formats, CXI and CFA, which stand for
+__C__TR e__X__ecutable __I__mage and __C__TR __F__ile __A__rchive, respectively.
+CXIs contain executable code, whereas CFAs cannot. CFAs usually accompany a CXI
+to provide other features such as the digital instruction manual, the Download Play
+child application, or in the case of game cartridges, system updates.
+
Both types of NCCH start with a header, and then followed by either an ExeFS
+image, a RomFS image, or both. The entire structure of an NCCH header may be best
+explained by a diagram:
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Solid lines are required sections, dashed lines cannot be used in some cases, and dotted lines are optional sections.
+
+
+
+
+
+
Now, games and applications need updates from time to time, and 3DSes handle these
+by installing the update as a seperate title from the base game. From that point
+on, whenever the user tries to launch the game, instead of loading the
+extended header (or ExHeader for short)
+and ExeFS image from the base game’s NCCH, it replaces them with the update’s
+ExHeader and ExeFS on launch. As for RomFS, the 3DS System Software will actually
+load both the base game’s and the update’s RomFS image, rather than replacing one
+with the other. Games are left to their own devices on how to handle these, and
+so the methods used per game can vary, though they usually just replace changed
+files, picking files from the base game RomFS if they haven’t been modified.
+
Citra, before this PR, had the code for loading games and reading NCCH files all
+mixed into one big piece that fit in with everything else. With this patch,
+shinyquagsire23 has seperated the loader
+from the NCCH reader, allowing the loader to read multiple NCCHs at once. Additionally,
+whenever a game is loaded, the loader would also check if there is an update title
+installed on Citra’s virtual SD card. If there is, it
+would replace the update ExHeader and ExeFS, and load the update RomFS as well.
+Just like a real console!
+
Most games worked out of the box with updates, and because they wrote the code
+with accuracy in mind, this very same PR has also laid part of the foundation
+needed to handle other features such as DLC support or even using real 3DS SD cards!
+Though, do note that we don’t have any estimates on either those or any other
+features, as no one is actively working on either.
The PICA200 GPU has a pipeline similar to OpenGL’s pipeline
+for rendering 3D objects into a 2D display. I won’t go through them all here,
+only the optional geometry shader step. Just after the vertex shader step, if
+enabled, all the vertices are processed by a shader kernel (which is a small
+program that runs directly on a GPU), taking as many vertices as the kernel
+wants as input, and outputting as many vertices as the kernel wants.
+
Because the kernel in the geometry shader is allowed as many inputs and outputs
+as it wants, it is significantly more powerful and flexible than the vertex shader,
+whose kernel is restricted to only one vertex at a time, both for input and output.
+But for that same reason, geometry shaders are much more complex to program, and
+so many games simply disable it. The games that do not disable it though, tend to
+use it very extensively, to the point of completely breaking graphics if it’s not
+implemented.
+
Multiple uses have been found in the wild for geometry shaders, including but absolutely
+not limited to:
+
+
+
Taking one vertex as input, and outputting a rectangle of vertices which can
+be textured with a sprite. Pokémon uses this extensively to render particles
+whenever a move is used. Monster Hunter takes it a step further and renders
+all of its HUD and GUI with this kernel.
+
+
+
Taking a handful of vertices as input, and outputting even more vertices which
+are interpolations between the inputs, thus making the resulting mesh look smoother
+and less jagged when rendered.
+
+
+
At first glance, geometry shaders looked like an easy problem, since they use the
+same instruction set and format as vertex shaders, so a lot of the same code could
+be reused. At second glance, it turned out that configuring inputs and outputs
+for geometry shaders is much more complex than it is for vertex shaders.
+
There were actually three attempts to implement geometry shaders in Citra. The first
+was written by ds84182 about two years ago, only to
+be abandoned due to not knowing how the configuration of them was done. The second
+attempt was written by JayFoxRox, but was also
+abandoned for the same reason.
+
But, after extensive research on geometry shaders was made by fincs,
+the API was implemented in ctrulib and
+citro3d, and examples were written to demonstrate
+how to use it. Now that the community knew exactly how they worked, wwylele
+picked up where JayFoxRox left off, cleaned up
+the code he wrote, and added the missing pieces.
+
After almost three years, and three different attempts to make it work, Citra now
+has a full, complete, and correct implementation of geometry shaders!
After the geometry shader (or the vertex shader, if it wasn’t enabled), the vertices
+are “assembled” into a collection of triangles. After that, to make rendering
+more efficient, the triangles are then compared to 6 planes that make up the cube
+in which objects are actually visible by the camera. Any triangles outside of that
+cube are deleted, and any triangles that are partially inside the cube are split
+by the sides of the cube, and the resulting triangle outside of the cube is also
+deleted.
+
But the 3DS allows games to add a 7th plane whose position is fully customizable.
+Although no games are known to use this feature right now, it is indeed a feature
+of the 3DS’ GPU. Because implementing it was fairly straightforward,
+wwylele decided to just go ahead and implement it,
+in case someone decided to use it in the future.
Morton code is a function that interleaves multi-dimensional numbers into a one-dimensional
+number. Although it may seem like a very esoteric function, it’s actually extremely
+useful in fields like linear algebra, databases, and what the 3DS uses it for:
+texture mapping.
+
Computers have an intermediate chunk of memory between RAM and the CPU called a
+cache. Caches are seperated into lines, each of which can hold one data item. GPUs
+also have a cache, also seperated into lines. Because they are seperated like this,
+if a texture is loaded into the cache, it would have to span multiple cache lines,
+or even not fit into the cache completely, thus making transformations on it slow,
+as it would have to load and store pieces of it from RAM multiple times.
+
To avoid this, GPUs can Morton encode textures so that two-dimensional manipulations
+are more likely to only need data already in the cache. Textures that have been
+Morton coded are usually referred to as swizzled or twiddled textures.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Not this Morton!
+
+
+
+
+
+
In the function that Morton is implemented, there was a lookup table on Morton
+codes in the comments, and huwpascoe thought it’d
+be best if we just use the lookup table directly. It worked just as well as before,
+but required less than a third of the math. Because this function is called so
+often during emulation (a rough estimate from them is about “millions of times a
+second”), this change although small, made very big changes in CPU performance.
The 3DS’ GPU has two main modes for drawing to the screen, immediate and batch
+mode. In the former, the GPU takes and immediately draws every vertex as it is
+handed to it. In the latter, the GPU accepts vertices given to it, but doesn’t
+actually bother drawing them until absolutely necessary, saving a bit of time
+from not having to go through the drawing procedure for every individual vertex.
+Although most games don’t use immediate mode at all due to it being extremely
+slow, a handful do use it for a handful of visual effects, like New Super Mario
+Bros. 2.
+
About a year ago when the GPU code on Citra was rewritten, a handful of calls to
+the drawing routine were removed, as it was believed they were unnecessary. Turns
+out, one of the calls was actually needed for some effects in games, as it handled
+immediate mode drawing. This wasn’t noticed for a very long time, as most games
+appeared to carry on with no side-effects at all from the rewrite, but was eventually
+found after some research courtesy of ds84182.
When a 3DS game needs some sort of audio processing, they can access the 3DS’ DSP,
+or __D__igital __S__ound __P__rocessor. It’s another processor, alongside the ARM9
+and ARM11, that is given a firmware to run, which in turn is given a bunch of audio
+samples and parameters by the game. The DSP then plays back the buffer in chunks
+of about 5 milliseconds. Each one of these chunks is called an audio frame.
+
As of today, we don’t know how the DSP exactly works, and we don’t know how any
+of the firmwares exactly work. (Did I forget to mention earlier there’s multiple
+versions of the firmware?) But we do know how to use it, and from there we can
+reimplement its behaviour directly in Citra. Which is exactly what MerryMage
+did back in June of 2016, which in turn brought audio support for the first time
+in Citra.
+
This approach, although having the advantages of being easier to implement, easier
+to understand in code, and has a higher potential of being faster, it has the
+disadvantage that accuracy suffers significantly, especially when shortcuts are
+taken for the sake of speed. One of these shortcuts was in the audio interpolation,
+which is a way of inferring more audio samples from relatively very few existing
+samples.
+
On a real 3DS, games are allowed to interpolate different audio frames with
+different functions, even when in they’re in the same buffer. On the other hand,
+Citra interpolated the entire buffer with one function as soon as it was loaded.
+This led to various effects and music in games to sound strange or inaccurate in
+some way.
+
One example of this is Deku Link’s footsteps in The Legend of Zelda: Majora’s Mask 3D.
+
Here’s the output of a real 3DS console, for reference:
+
+
+
And here’s the output of Citra, before this was fixed:
+
+
+
Now that it’s been fixed, his footsteps sound a lot better:
+
+
+
Audio emulation in Citra is still somewhat inaccurate for now, though
+MerryMage is gradually working on fixing and
+improving it. Perhaps some day we may even be able to emulate the DSP firmware
+directly, which will be much more accurate than merely emulating its behaviour.
Whenever the DSP consumes some frames from the audio buffer, Citra deletes them
+from it. This normally wouldn’t pose any problems, but because the buffer was
+being stored as a vector, this led to some uneccessary operations. Namely, the
+C++ standard requires that all the data of a standard vector be in one contiguous
+block of memory. Because deleting frames from the buffer breaks this rule, Citra
+would automatically (1) allocate a new block of memory, (2) copy the entire buffer
+into that new block of memory, and (3) deallocate the old block of memory, thus
+deleting the old buffer.
+
These steps are huge waste of time, as Citra doesn’t need to guarantee that the
+audio buffer is in one contiguous block. So Subv changed
+the type of the buffer from a vector to a deque, which is essentially a queue that
+you can remove data from both the beginning and end of it. Because the contiguity
+requirement doesn’t exist in deques, Citra doesn’t do the uneccessary copying,
+leading to huge speed boosts in audio bound titles like Super Mario 3D Land, and
+even the Home Menu. Now, both run significantly faster!
When a program is written in a high-level programming language, such as C++, Rust,
+or Go, before the program can be run on a machine, it must be translated or “compiled”
+to machine code. Although it is possible to do this translation by hand, it is
+usually extremely difficult to do so and very time consuming. So instead, we have
+a program called a compiler than can automatically do this translation for us.
+
This is also why a program compiled for an ARM machine cannot be run directly on
+an x86 machine, even when the source can work on either machine without issues.
+Instead this program must be translated, interpreted, or recompiled from source
+to x86. (In fact, this translation is exactly what dynarmic
+does to run code from a 3DS.)
+
Every statement in a program must have an exact, unambiguous definition of what
+it does (its semantics). But, in the same way that a statement that means one
+thing can be written many different ways, and different compilers can translate the
+same statement many different ways.
+
On Windows, there’s two popular C++ compilers available as of today: MSVC++, which
+is the compiler Microsoft has written for Windows, and MINGW GCC, which is actually
+a port of the Linux gcc compiler to Windows. For better or worse, MINGW GCC
+optimizes Citra a little better than MSVC++, and so jroweboy
+has changed the Citra AppVeyor build script to add support for MINGW GCC as well
+as MSVC++. Do note that the MSVC++ builds are only available through GitHub, since
+they’re only useful for debugging, and MINGW GCC builds are faster in most, if
+not all, cases, which is why the installer will only install those. This change
+also has closed the gap in performance the new Nightly builds had compared to
+the old Bleeding Edge builds.
Remember that last month wwylele changed Citra so
+that instead of loading the shared font from a seperate file, it would
+load it from the system archive?
+This builds on top of that behaviour. You see, a 3DS doesn’t have a shared font,
+it has four. One contains glyphs for Latin script (for English, Spanish, Italian,
+French, etc.) and Japanese scripts, another contains glyphs for Traditional Chinese,
+the third font contains those for Simplified Chinese, and the last font contains
+the ones for Korean.
+
Before this PR, Citra would simply load the first shared font regardless of game
+or region. This made non-Latin or non-Japanese script games display completely
+incorrect characters at best, or crash at worst. Now Citra will load the appropriate
+shared font from the system archive depending on the region selected, just like
+a real console! Though, this will not work on machines that only have the
+shared_font.bin file, because it only contains the shared font for the region
+of the console it was dumped from. (e.g.: If you dump a Korean console, it’ll
+only contain the Korean font.) If you want to use this feature, you must dump
+the system archive using the latest version of 3dsutils.
+
Et. al.
+
And of course, big thanks to everyone who’s contributed
+this September, because Citra as a whole would not be the same without everyone
+involved having placed their pieces, big or small.
It’s been a while folks - since the last report, we have had many new features come to Citra. Some
+notable ones include multiplayer improvements, hardware shader improvements (post GLvtx), a logging
+system rewrite, and the highly coveted camera support. Our continuous integration (CI) systems were
+optimized as well. Apart from these, we have had many more minor features, improvements, and bug fixes.
+So, without further ado let’s get right into it:
Citra has been able to run many games at playable speeds for a while now. However, it was always lacking
+something which the 3DS has: the ability to play with friends. In order to make it a reality, our developers jroweboy, B3n30, Subv,
+and JayFoxRox worked tirelessly for months to reverse engineer workings
+of the 3DS local wireless system. Thanks to their efforts, Citra now emulates local wireless multiplayer
+over the internet. This allows you to play your favorite games with your virtual friends across the world.
+Later jroweboy, B3n30, and few others
+worked on various feature improvements and bug fixes.
+
Features
+
Currently, the multiplayer features include:
+
+
We now have multiple servers, maintained by our very own FlameSage
+and many other community members at various locations around the globe, so that you can meet others
+online.
+
You can now create rooms which can hold up to 16 players and even secure them with a password.
+
You can now set a preferred game for your room.
+
You can also filter the servers to suit your needs.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Sooo many servers to choose from!
+
+
+
+
+
+
Since its initial release in Canary, developers have listened to the community and have been trying
+very hard to fix bugs causing games to be incompatible. They have also added other features to make
+the multiplayer experience richer.
+
Compatible Titles
+
We are proud to announce that multiplayer currently works in the following list of titles:
+
+
Dragon Quest Monsters: Joker 3 Professional
+
Luigi’s Mansion: Dark Moon
+
Mario Party: The Top 100
+
Monster Hunter 3G & 3 Ultimate
+
Monster Hunter 4, 4G & 4 Ultimate
+
Monster Hunter X
+
Monster Hunter XX
+
New Super Mario Bros. 2
+
Pokémon Omega Ruby / Alpha Sapphire
+
Pokémon Sun / Moon
+
Pokémon Ultra Sun / Ultra Moon
+
Pokémon Virtual Console
+
Super Smash Bros.
+
The Legend of Zelda: Tri Force Heroes
+
And many more.
+
+
Incompatible Titles
+
For various reasons, the following games were tested and do not work:
+
+
Asphalt Assault 3D
+
Code of Princess (a fix is in works)
+
Dragon Quest Monsters: Terry’s Wonderland 3D
+
F1 2011
+
Kirby Fighters Deluxe
+
Kirby Triple Deluxe
+
Mario Party Island Tour
+
Mario Party Star Rush
+
Mario Kart 7
+
Planet Crashers
+
Resident Evil: The Mercenaries 3D
+
Ridge Racer 3D
+
Sonic Generations
+
Street Fighter IV
+
Tetris Ultimate
+
+
Note that this list isn’t absolute, and multiplayer may or may not work in games not listed here.
+Also note that Download Play and Spotpass titles do not work as they are beyond the scope of current
+local multiplayer.
+
Although multiplayer is supported, some games might still experience issues with it. Since the servers
+are located in various locations, latency will play a major role in your gameplay experience, so always
+choose a server that is nearby (geographically). Please use our support forums,
+IRC, or Discord for
+help regarding issues with multiplayer.
+
Read more about the multiplayer feature update here.
+
citra-qt: Hardware Shader Improvements (post GLvtx) by wwylele and degasus
+
Citra has come a long way from just being able to render graphics in 2015, to being able to run games
+at a playable state. Still, Citra was only fast for users who had better hardware. Users with slower
+processors suffered from lag and stuttering during gameplay.
+
Now, thanks to the combined efforts of phantom, jroweboy, wwylele, MerryMage, and many more, we
+now have a near-complete hardware renderer with huge improvements. Citra now uses the host GPU to its
+fullest to render graphics. wwylele and MerryMage
+took it upon themselves to simplify the humongous heap of code into smaller parts, fixing, and testing
+them.
+
Thanks to degasus from the Dolphin community, who imparted his valuable
+knowledge and understanding of GPUs and OpenGL, we were able to optimize the streaming storage buffer
+support added by phantom. This was done entirely by degasus
+himself (here, there,
+and that). The old way to upload the data (both vertex
+and constants) was a simple glBufferData call. Keep in mind, however, that the GPU has a huge execution
+latency, so you can’t just copy the new content over the existing buffer. The driver has to choose
+between different ways to deal with this issue, with different drawbacks:
+
+
Wait for the GPU to finish and copy to the destination buffer. Usually this method is the fastest
+for big uploads, fine on common gaming, but terrible for emulators.
+
Allocate a new buffer and tell the GPU which new buffer shall be used now. You also need to care
+about freeing the old buffer once it isn’t in use any more. This tends to have a huge CPU overhead and
+isn’t available on partial buffer updates such as lighting LUTs.
+
Copy the data to an internal staging buffer and ask the GPU to copy it again to the destination
+when it is ready. This uses twice the memory bandwidth, and switching between rendering and copying also
+takes a while for the GPU. This proves to be a significant bottleneck if done for every single draw call.
+
+
In the end, all of these are bad in terms of performance. It is a simple upload call, but it either
+requires many copies and context switches, or the GPU is stalled (More on that in here). Instead, Citra
+allocates a big staging buffer, copies the data to the current position within the buffer,
+and tells the GPU to directly access the data from there. The driver has no scope of interpreting what
+we ask it to do.
+
This has a downside as well. The GPU now accesses the main memory over PCIe. So if we’re going to
+reuse the same data in the next frame, it has to go through the PCIe bottleneck again. But, we never
+use the same data again and hence gain a big performance boost.
+
wwylele tweaked the configuration UI and renamed some parts of it.
+However, this caused some confusion about the configuration window and GPU features.
+
What’s changed in the UI?
+
With the initial release of GLvtx, we added support for running shaders on the host GPU. So, we had
+a dropdown menu called Shader Emulation to select either CPU or GPU, to run the shaders. The
+option has now been renamed as Enable Hardware Shader. When enabled, it makes use of the host
+GPU, and when disabled, it uses the CPU alone.
+
Due to many of the users having older hardware, we introduced an option called Accurate Hardware
+Shader. It was later renamed to Accurate Multiplication, because technically that’s what it was
+doing. When enabled it would render games with more accuracy at the cost of slower performance.
+Same goes for Accurate Geometry Shader. Earlier this was configurable via the INI file, but now
+it can be configured in the UI.
During it’s time in Canary, a lot of testing was done by our contributors. They tested many games,
+under varied hardware conditions and submitted valuable telemetry data, crash logs, etc., which helped
+us in fixing issues with the hardware shader support.
+
Note:
+Unfortunately, due to driver issues with AMD GPUs and inadequate OpenGL support on macOS, the hardware
+shader might not perform better than the software renderer under these conditions. However, worry not,
+as research is being done into possible fixes that might come around sooner than you think.
+
Read more about hardware renderer improvements in detail here.
One of the more time and resource consuming parts of the project were our build generating environments.
+We use Travis and Appveyor to release fully functional builds for download. However, the time it took
+for the builds to be created was too long and if it was stopped abruptly, it took even more time to
+create the builds again. Thanks to liushuyu’s contributions, we were
+able to optimize this whole process and make it very efficient to build and release latest changes to
+our site.
Our old logging system had several drawbacks and was due to be updated. So, a newer and efficient
+logging system based on fmtlib was designed and implemented by jroweboy
+and daniellimws. This gets rid of the ugly console window and made
+many under the hood improvements to the logging system. This will make identifying and fixing issues
+a whole lot faster. After the implemetation was done, migrating our codebase to the new system was a
+huge endeavour shared by daniellimws, and many others.
One of the highly requested features of Citra has been the support for using the system camera to
+scan QR codes and other kinds of images. zhaowenlan1779 took it
+upon himself to provide Citra with this feature. By making use of the available Qt libraries, he worked
+on the implementation for weeks and was finally able to finish the feature. Citra now boasts the ability
+to directly scan images and use the system camera in a manner similar to the 3DS camera.
For a long while now, Citra’s UI had been in English and has had absolutely no support for other languages. wwylele discussed this at length with other contributors and finally
+brought UI translations to Citra. Citra can now be used in many other languages. Note that these
+translations are maintained by our own community members and the translations are hosted on
+Transifex. Now, you too can submit a translation for your
+language (if it doesn’t exist already), or review existing translations to make them accurate.
Over the years, Citra has improved by leaps and bounds. However, there has always been a lack of consistent
+information on game compatibility. We introduced the game compatibility list
+to fix that. Having a list was helpful, but maintaining it was proving to be a tedious task. After a
+lot of brainstorming, BreadFish64 added the option in the UI to send
+test cases via telemetry. These results are submitted by the users themselves, and are in turn used to
+update the game compatibility list.
+
+Note: To be able to report compatibility, you have to first login to the Citra Web Service, using
+your Username and Token.
+(See Emulation -> Configure -> Web)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Citra Web Service
+
+
+
+
+
+
Miscellaneous
+
Various other contributions to the external dependencies have been made by Lioncash, MerryMage, and many others. Several services were converted to the new
+service framework (here). Many minor bug fixes and
+under-the-hood feature improvements were done by our contributors.
+We believe even the smallest contribution is valuable and without these contributors,
+these new features wouldn’t have been possible.
Hello everyone to the summer (or winter, for those on the southern half of this
+Earth) edition of Citra’s progress reports. Although not very many large changes
+have been made, many fixes have focused on accuracy improvements and implementing
+some of the sorely needed user experience features.
+
Before we go further into this, our Patreon
+poll results are out.
+We asked our patrons, which feature they would like to see us work on next and
+they delivered. Here are the results and as you will see, some of these have
+been considered and already implemented.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Patreon Poll Results
+
+
+
+
+
+
To get access to such exclusives in the future and to support this project,
+consider becoming a patron. Now, enough appetizing, have your entrée:
Let’s start with a simple but sweet one — you can now assign hotkeys to
+pausing, unpausing, and toggling speed limiting. By default, you can pause with
+F4 and toggle speed limiting with Ctrl+Z.
+But, of course, you can bind these actions to other keys in Citra’s qt-config.ini.
+The property for pausing is Shortcuts\Main%20Window\Continue\Pause\KeySeq and
+for speed toggling it is Shortcuts\Main%20Window\Toggle%20Speed%20Limit\KeySeq.
You can now configure Citra to search multiple directories for games and apps!
+This allow you to keep titles across different folders, and if you have any
+launchable titles installed into Citra’s virtual SD card or NAND, they’ll also
+show up in their own section so you can boot them from the game list.
If you are one of the lucky few with a 3D TV or monitor attached to your
+computer, stereoscopic 3D support has just been added to Citra! You can enable
+it by heading to Emulation → Configure… → Graphics → Layout,
+ticking the Enable Stereoscopic 3D checkbox, and changing the
+screen layout to Side by Side.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Although you can’t see this in 3D, try crossing your eyes or using a mirror!
+
For the longest time, many games were unplayable or needed workarounds on Citra
+due to them needing the software keyboard applet. The reason being that whenever
+they would try to open it, Citra didn’t implement it, and so would simply tell
+the game that the user entered “Citra” and tapped OK, without actually prompting.
+But now, thanks to zhaowenlan1779 and jroweboy, it now has fully functional
+software keyboard emulation!
+
Whenever a game requests it, Citra will pause the game and pull up a text box that
+you can fill in like any other prompt.
Many Nintendo 3DS games require the use of system archives, which contain things
+like fonts, a bad word list, and assets for Miis. Because these are copyrighted,
+Citra could not include them, and users had to dump a copy from their consoles,
+which was a generally tedious and error-prone process.
+
Now, B3n30 has created open source alternative fonts
+and a bad word list that can be used in games instead of the official archives.
+And, because these are open source, they are now included with Citra. If a game
+requires either archive, and you haven’t dumped them yet, it’ll automatically give
+the game the alternative archives. This is a step forward to Citra becoming
+a full-fledged HLE 3DS emulator.
Shadow mapping is a way to quickly apply shadows to 3D scenes. It first renders
+the scene without any lighting, texture, or colour information, with a virtual
+camera from where the light source begins. Then, from that rendering the depth
+map is extracted. That is then applied as a texture to the darkened scene, making
+areas of it directly visible from the light source appear more brightly lit.
+
The PICA200 (the GPU inside the 3DS) and OpenGL both implement this in different
+ways, particularly in two important areas:
+
+
+
The first is that PICA200 supports a variant called “soft shadows”, where the
+depth map is blurred before being applied to the scene. This results in shadows
+that seem less jagged and sharp, making the light source feel more diffuse and
+evenly spread out throughout the scene. OpenGL doesn’t support this at all.
+
+
+
The second is that the PICA200 stores depth maps intended for shadow mapping as
+plain textures in the RGBA8 format. A lot of games exploit this in order to quickly
+convert other types of textures from an internal format to RGBA8. But, OpenGL
+stores these maps in a format internal to that graphics card, like any other map.
+(RGBA8 or 8bit RGBA is a texture format, which is the combination of an RGB
+(red green blue) color model with an extra 4th alpha channel.)
+
+
+
The first point isn’t as significant, since the softness can be ignored on OpenGL,
+resulting in a very fast (but inaccurate) shadow mapping. Because games rarely
+use soft shadows, this can be ignored relatively safely.
+
The second point though, because games use it very often, it has to be implemented
+accurately. The naïve way would be to simply convert internal textures to RGBA8
+manually, but this would slow rendering down to a crawl. The smart way would be
+to try and trick the graphics card driver into performing a similar conversion,
+but such an attempt exposed a lot of issues, leading to instability.
+
After some very hard work by wwylele, both problems
+were solved with a single solution. OpenGL supports an extension called
+Image Load/Store, which allows shaders to read and write to any texture
+directly. Using this, he created a shader that could accurately implement both
+soft shadows, and convert the depth map from its internal format to RGBA8 very
+quickly.
Unfortunately, because Image Load/Store is an optional extension, not every
+OpenGL 3.3 graphics card will support it. In these cases, Citra will simply ignore
+shadow maps, making the rendering inaccurate but usable. Image Load/Store became
+a mandatory part of OpenGL in version 4.2, so every graphics card that complies
+with OpenGL 4.2 is guaranteed to work correctly.
+Citra only requires a minimum
+compliance to OpenGL 3.3, but OpenGL 4.2 compliance may lead to more accurate
+rendering.
cubeb is an audio library (developed by
+the Mozilla Foundation) that’s cross-platform, and most importantly fast.
+Reports from Dolphin’s blog
+showed that it ran at a third of the latency of their OpenAL backend. And now,
+thanks to the work done by darkf and some fixes
+from MerryMage, Citra can now benefit from that
+same low latency audio that Dolphin and Mozilla Firefox have. This will lead to
+significantly less distortion and stuttering in your games. Just remember to
+enable it in the configuration menu by setting Output Engine as cubeb.
You can now configure the volume level of Citra directly from the configuration
+window. This allows you to set an individual volume level for Citra without
+having to manually set it in your operating system settings.
Rich Presence allows you to leverage the totally boring “Now Playing” section
+in a Discord user’s profile. This feature lets users show off when they are
+playing their favorite games on Citra. This has been a common feature request
+from many users, and since many other emulators have already implemented this,
+it made sense to implement it here as well.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Discord Rich Presence
+
+
+
+
+
+
Discord Rich Presence works by creating a local connection with Citra and your
+Discord App. It does not connect to (or) send any data to Discord servers.
+This option is user configurable, so you can choose to show or not to show rich
+presence in your discord status. Just head out to Emulation
+→ Configure… → Web → Discord
+Presence and check / uncheck “Show current game in your Discord
+status”.
The majority of support requests we get are mostly due to users accidentally
+enabling or disabling some settings. But now with this feature, we have
+default values for all our settings. This ensures that in case of any new
+settings changes, majority of the users (who haven’t customized those settings)
+will now have the new default value automatically.
You can now directly use your encrypted game dumps in Citra, without having to
+decrypt them. This requires that the user provide their keys via a text file
+in sysdata/aes_keys.txt.
+
Currently all known encryption methods are implemented except for the Seed
+crypto. Seed crypto is used in newer eshop games, which essentially uses an
+additional title-unique key that is stored outside of the ROM.
Scripting is an extremely useful feature which allows us to do things like
+debugging emulator internals, reverse engineering 3DS game internals,
+Tool-Assisted-Speedrunning (TAS), and the ability to manipulate memory in
+games. A cheat-like interface could be implemented through this (though, not
+specifically Gameshark / AR codes).
+
Users can make their own scripts or use publicly available scripts to gain
+power over things like game screen display, inputs, and memory. Scripts can
+also be used to read or modify the internal game state. EverOddish wrote some
+scripts that can read internal stats of the Pokémon and automatically
+update image files for your current party. This feature is very useful for
+streamers who might want to display game information on their streams.
This feature, not to be confused with video/audio recording, implements a way
+to record game inputs and play them back. Every time the hardware reads an
+input device (buttons, touch screen, accelerometer, gyroscope, c-stick) the
+emulator copies (when recording) or replaces (when playing) the values. Once
+playback has finished, we release control of inputs so that the user can take
+control.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ UI options to record
+
+
+
+
+
+
For this, danzel heavily took inspiration from dolphin’s system and zhaowenlan1779
+wrote the UI for this feature. This method results in .ctm (Citra TAS movie)
+files which are playble in Citra. To play a game’s .ctm file you would need
+to have the game and also manually set Citra’s system time to the same starting
+value as in the .ctm. This feature makes debugging bugs in games much easier,
+as it doesn’t require us to go through the whole process again.
Whenever a game requested time information, Citra always used your PC’s system
+time. This method had a couple of issues - for example, if you were playing a game
+at 200% speed for 2 hours. As its running at twice the max speed, playing for
+2 hours in real-time should reflect 4 hours simulated time. But, due to Citra
+sending your PC’s time to games, it wasn’t happening.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ System Time setting (edited to show both options)
+
+
+
+
+
+
Also, players might want to set Citra’s time to a specific value to ensure
+consistency with TAS or with RNG(random number generator) or for getting
+time specific game events. Earlier you had to modify your PC’s system time
+to achieve this but thanks to B3N30, you can now just set it in Citra’s
+configuration window.
For a long time, Citra didn’t support controller hot plugging. This meant that
+if by chance your controller disconnected Citra would fail to detect it after
+re-connection, unless you restarted the emulator. This caused a lot of
+frustration among users who preferred playing with controllers.
+
Hot plugging (also called hot swapping) is the ability to add and remove
+devices to a computer system while the computer is running and have the
+operating system automatically recognize the change.
+
Thanks to the efforts of B3N30 and jroweboy
+(who researched SDL controller configuration), Citra now doesn’t fail to detect
+your controllers in case of a disconnection. However, due to heavy rework of
+the existing input configuration code, this requires users to reconfigure their
+controllers after updating Citra.
Citra’s previous motion controls were a bit uncomfortable to use. You had to
+use your mouse’s right-click and drag to tilt the screen, but it was often
+hard to figure out where to move the cursor to get the kind of tilt we want.
+
Using a real device for motion controls is simply much more intuitive and will
+be an all around better experience for users. As such, jroweboy set out to
+implement cemuhook motion/touch protocol which adds the ability for users to
+connect several different devices to citra to send direct motion and touch
+data to citra.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Motion/Touch Configuration Window
+
+
+
+
+
+
Cemuhook is a very popular plugin developed by rajkosto
+for Cemu - the Wii U emulator. This protocol was chosen simply because of the
+fact that there aren’t many alternatives and this already has good device
+support. Moreover, as it uses UDP, it works on just about anything with a
+network stack and allows the server to even be a remote network device (useful
+for Android motion support). zhaowenlan1779 wrote the UI for this feature,
+to make it easily accessible and configurable by all users.
+
Et. al.
+
Apart from the above mentioned ones, we have also had a lot of minor optimizations
+and bug fixes ported from yuzu. We’ve made changes to our authentication system
+to use JWT (JSON web tokens), added a background color selector, made GDB stub
+improvements, and many more.
+
Thank you to everyone
+for pouring your blood and sweat into this project. Citra needs contributors
+like you to stay alive and become the best it can be.
+
+
+Please consider supporting us on [Patreon](https://www.patreon.com/citraemu)!
+If you would like to contribute to this project, checkout our [GitHub](https://github.com/citra-emu/citra)!
+
Hey there, Citra fans! These past 6 months have been crazily exciting, and simply wonderful for Citra overall.
+We’ve made major breakthroughs which were long overdue.
+New features, bug fixes, performance improvements, improved game compatibility, and much more await you.
+So buckle up and enjoy the ride!
+
+
To start off, back in August, we asked our patrons to vote on what they’d like to see us work on the most, and now it’s time to review how much progress we’ve made on everything since then.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Patreon Poll Results
+
+
+
+
+
+
#0 Pokémon X/Y Support
+
We are just as happy as everyone else to finally have Pokémon X/Y support after so many years!
+We didn’t include this one in the survey because, at the time, we weren’t even sure if the long time spent on developing the new audio core code would fix the game.
+But all the work wwylele put in paid off, and you can read more about it in the full article here.
+
Also, not mentioned in the article, developers B3N30 and liushuyu have put in extra work on the HLE (fast) audio code to support Pokémon X/Y as well.
+At first, this new HLE code was using patented decoders that Citra could not legally distribute, making it painfully complex for anyone that wanted to test it out.
+But with way more effort than anyone expected, we were able to modify the HLE code to use Microsoft’s Media Foundation framework, which allowed us to ship HLE (fast) audio support for Pokémon X/Y without any patent issues.
+
Here is a gameplay video of Pokemon X/Y, which showcases just how fast and great the HLE (fast) method is.
+It still has some slight crackling and has room for improvements, but apart from that it’s just amazing.
+
+
+
+
+
+
#1 New 3DS Support
+
In September, developer B3N30 started deep research into what exactly it would take to fully support New 3DS (N3DS) games in Citra.
+Keep in mind that we wanted to implement full support, which involves more than just hacking it on top of what Citra has today.
+On the hardware level, the N3DS adds some additional memory and, most importantly, 2 new CPU cores, one that’s dedicated to facial tracking and one that games can run code on.
+And on the software level, it has a few new N3DS-specific services, mostly just to let the game know that it’s running on a N3DS.
+
The challenge with adding N3DS support ended up almost completely within the scheduler, as increasing the emulated memory and CPU count were pretty straightforward.
+Citra’s current implementation is written exclusively to run all 3DS code on one emulated core, something that works great for just about every game out there, as that’s how it works on real 3DS hardware too!
+But N3DS games (and a small number of Old 3DS games) can run code on another core, which we don’t have any support for at this time in Citra.
+
After a few months of playing around with the code, B3N30 had to take a break, as it was too exhausting trying to reverse-engineer how the 3DS schedules across multiple cores and recreate this in Citra at that time.
+It’s an open secret in the 3DS reverse engineering scene that the 3DS scheduler is devilishly complex.
+So while we do plan to continue working on this, sometimes you just need to take a break and come back with a fresh perspective.
+
#2 Splittable Screens
+
Developer jroweboy started work on splitting screens to multiple windows in Citra a good while ago, but almost immediately ran into an issue.
+This task touched many parts of the code that are very core to the emulator, and changing them proved to be a little challenging.
+While these technical challenges are easy for the devs to handle, the real challenge was developing a clear and usable UI/UX for the feature.
+
Creating a multiwindow system intuitive enough for users to discover how it works, powerful enough to cover everyone’s preferred use cases, and still simple enough to not cause massive maintenance burden, is a very challenging design goal to meet.
+
Most developers have a passion for working on complicated core emulator projects, but a good emulator should also be user-friendly and easy to use, and that’s not something emulator developers usually have much experience in.
+We do want splittable screens, but we won’t settle with a bad design for it.
+If you have decent experience with UI/UX design and want to contribute, let’s talk and work together to make a good design for splittable screens.
In response to the initial survey results, both jroweboy and B3N30 set out to change the controller handling code in Citra to support hotplugging.
+On the surface level, the bare minimum requirement was that one could unplug and replug in a controller and Citra would continue using it.
+But deep down, Citra needed a little bit of restructuring for this to possibly be implemented.
+
What followed was a full redesign of the controller backend to not only make controller hotplugging a reality, but to also remove any global state from the controller backend.
+Usually global state in any multi-threaded software is considered very bad, as it can make the program unpredictable and unreliable, and makes future code modifications unnecessarily complex.
+It’s always a good day when you add a new feature and leave the code in better shape than ever before!
At first, we were nervous about including cheats in the survey, as we have a long history with cheat codes not working on Citra.
+But we added it anyway, since we were confident that if people wanted cheat codes, we could finally resolve the long-standing bug that kept cheat codes from working correctly.
+
While developers B3N30 and jroweboy were busy with controller code, wwylele was working on cleaning up the core emulator code, trying to remove any global state.
+Along the way, wwylele found that the way memory is handled in Citra wasn’t truly accurate to how the hardware works.
+What started as a routine clean-up to remove global memory ended with wwylelerewriting how almost all of the memory works in Citra!
+
When users started testing out games to see what broke and what got fixed, they also took to rebasing makotech222’s old cheat code support and tested to see if cheats were working again; surprisingly, they were.
+Word spread quickly that cheat codes were now working again, so after finishing controller hotplugging support, B3N30 worked on implementing cheat code support in Citra.
+He based his implementation on the old PR, but vastly improved it by rewriting many parts and fixing the many design flaws it had.
+Thanks to another developer, zhaowenlan1779, who implemented the UI for cheats, full cheat code support is now available in the latest Nightly and Canary builds.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Cheats Interface
+
+
+
+
+
+
#5 Custom Texture Support
+
As you’ve seen thus far, we’ve had our hands full between Pokémon X/Y, cheats, controller rewrite, and more.
+While we still want this feature, it’s currently not in development, and we don’t have any estimate for when someone will add it, either.
+Stay tuned, though, as the open nature of the project means that this can change at a moment’s notice.
+You never know when a current Citra developer might pick it up, or when a new contributor might submit the code for review!
Developer FearlessTobi works tirelessly to try and keep the code that’s shared between the sister project yuzu up to date with Citra.
+Recently, a yuzu developer ogniK added support for amiibo to yuzu, and Tobi really wanted to know how much of it could just be copy-pasted into Citra.
+
It turns out, a fair bit, but not quite enough to get it working out of the box.
+With some extra research and some help from ogniK, Tobi was able to work out the differences and bring amiibo support to Citra in October.
+This works by using Virtual amiibo files, which emulates the scanning of them.
+To obtain these Virtual amiibo files from your physical amiibo, you can either use the TagMo app for Android or a 3DS homebrew app.
Developer jroweboy picked up this task back in November, but ran into a roadblock just as he was about to finish it.
+There was some bug in the code that prevented games from accepting the mic input, but after reviewing it several times and debugging it, he just couldn’t figure out what it was.
+
In the past week, FearlessTobi took an interest in the code for the mic, and decided to try and clean it up a bit.
+During his clean-up, he tested his code out and found out that it had somehow started working.
+By reviewing the differences in the two copies of the code, jroweboy found that he had mixed up bits and bytes for the size of mic_data, a silly oversight.
+Because of this mistake, the mic implementation wasn’t copying enough data to the game.
+Following this breakthrough, jroweboy took the chance to clean everything up, added support for mic switching while a game is running, and set the stage for future microphones such as for Android support.
+Microphone support is now available in both Nightly and Canary builds of Citra.
+
+
+
+
+
+
#8 Background Images for the UI
+
It’s not too surprising that this is not heavily requested, as it has very niche uses for streamers and YouTubers who use Citra.
+Either way, if the demand for such a feature increases, we could take a little time to add it, but we have no plans to work on this currently as it’s not a high priority.
+Accurate emulation, followed closely by making that accurate emulation fast, is always the No. 1 priority.
+
+
As you might’ve already noticed, we’ve also had many other features added to Citra in these past 6 months.
+They weren’t covered in a blog article, so let’s take a quick glance at all the new additions:
Thanks to the collaboration of developers Flame Sage and zhaowenlan1779, the new multiplayer update which came a few months ago brought many improvements to Citra’s multiplayer experience.
+A brief overview of these improvements:
+
+
+
Users who verify their Citra Web Services account will now have their username and avatar displayed in public rooms. You can also right-click to view their Citra community profile.
+
+
+
Room moderation: Hosts of verified rooms can now perform basic moderation actions in their own rooms. Hosts can now kick or ban a user, and remove bans if needed.
+Room bans will ban both the user’s Citra Web Services account (if authenticated) and IP address.
+Optionally, room hosts can also choose to grant access to Citra moderators, to moderate their rooms.
+
+
+
Rooms descriptions: You can now optionally add a description to your room.
+This is accessible both in the UI and on the command line.
+
+
+
Console ID check: Sometimes multiple Citra users will have the same virtual Console ID; this is not supposed to happen on real consoles, and as such can confuse games a lot.
+A Console ID conflict check will now be performed, and users won’t be permitted to join if they have the same Console ID as someone else in the room.
+
+
+
When the room is full, instead of a general “Unable to connect” message, a proper error message will now be displayed.
+
+
+
You can now see info messages like “joined” and “left” in the chat.
+Additionally, moderation actions like kicking and banning will also be shown to all room members.
+
+
+
User pinging: You can now ping other users with @Username or @Nickname.
+Pinged users will get a notification on their desktop and the message will be highlighted.
With many new features being added to Citra regularly, the old configuration window was getting crammed.
+While a vision for a better UI (user interface) has existed since the early years of Citra, no actual work was done towards it.
+Upon jroweboy’s request, spycrab, a well-known developer from Dolphin, undertook the implementation of such an interface.
+We plan to further improve upon this interface design, to ensure the best possible user experience in the future.
As part of our continued efforts towards open source system archives, wwylele implemented open-source replacements for the country list archive and the Mii data archive.
+Like the name implies, the country list archive is a list of all countries in which the Nintendo eShop provides services.
+The open-source Mii data archive is a placeholder with empty models and textures.
+This makes Miis display a sign indicating that the Mii data is missing, instead of just letting games crash.
+With these, we now have open source implementations of all the necessary system archives except the shared fonts for CHN/KOR/TWN regions.
+
Until now, the most common cause of Citra crashes has been missing system files.
+System files are part of the 3DS operating system, not the games themselves, meaning that when you copy a game from your 3DS to your PC, sometimes you don’t actually have everything needed to run the game.
+The most notorious and common system file is the shared font that games could load and use to render text, but ever since B3N30 added a custom font for Citra, the number of crash reports has dropped dramatically.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Open Source Mii Data
+
+
+
+
+
+
Since the beginning, Citra has always worked to recreate the entire 3DS ecosystem, so this marks a special occasion where almost every game is functional without needing to dump additional files.
+While this is a great milestone, we are programmers and not artists!
+Along the way, wwylele built tools for the community to recreate and import custom-made textures and models for Miis, meaning that now anyone can contribute.
+If you are skilled with 3D modelling and would like your work to become the default faces of Miis in Citra, reach out to us and let us know!
For a long while now, Citra has only supported decrypted ROM dumps, not encrypted ones.
+Normally, the ROM dumping process would make use of secure keys in the 3DS system and generate decrypted ROMs as output.
+Supporting encrypted ROMs in Citra meant that we had to first extract these keys from the 3DS and then make Citra use them to read and decrypt encrypted ROMS on the fly.
+
Before we even got to implementing stuff on Citra’s end, we had a major obstacle.
+Until now, not much research had been done to figure out how to obtain these keys all together.
+Developers wwylele and B3N30 did the necessary research and slowly implemented support for encrypted ROMs.
+Users can now follow the guide here to obtain these encryption keys, with which Citra will be able to read encrypted ROMs or install encrypted CIAs directly.
+
Note: Although we now support encrypted ROMs, dumping decrypted ROMs is still recommended for general use.
For a long time, users have requested an option to add more Play Coins in Citra.
+Play Coins is a 3DS feature that is intended to reward players for being physically active by counting steps taken while the console is in one’s pocket, using motion tracking.
+The system rewards a Play Coin for every 100 steps, up to 10 coins per day, and up to 300 total.
+These can then be redeemed in various games.
+Citra can’t track your device’s movement, so the ability to add Play Coins through Citra’s UI would be helpful for anyone wanting to play games that use them.
+
While attempts were made to implement this in the past, the code behind the implementation wasn’t very good.
+zhaowenlan1779 did some research into the ptm service, which is responsible for Play Coins, and implemented this long-requested feature.
+With this, Citra users now have 42 Play Coins by default, and can add more, up to the usual limit of 300.
Although Citra emulated the 3DS touchscreen, it was found that it didn’t work on physical touchscreens.
+To put it simply, Citra wasn’t able to parse inputs from an actual touchscreen display.
+This issue was first documented by MerryMage and has been waiting for someone to actually fix it for some time.
+
NeatNit encountered the same issue and came forward to attempt fixing it.
+He researched the workings of both the Qt and SDL frontends, took help from other developers, and found that physical touchscreens weren’t implemented in Citra frontends at all.
+As a fix for this, NeatNit implemented touch events in both of the frontends, and finally got inputs working on physical touchscreens.
To further improve TAS (Tool-assisted Speedrunning) on Citra, developer zhaowenlan1779 implemented the Frame Advancing feature.
+Frame advancing is a commonly used TAS feature which basically means running the game frame by frame. TASers use this feature to press exact buttons on specific frames.
+Furthermore, he added an init time field to the CTM (Citra TAS Movie) header, which ensures RNG consistency when replaying a CTM file.
In general, people like to share their in-game experiences by means of images, video clips, etc., which have required third-party tools to create.
+This can sometimes get confusing and frustrating, as these tools can lead to weird bugs when used in overlay.
+The solution?
+Adding native screenshot functionality to Citra.
+
While this sounds simple enough, in reality, designing this feature to meet our requirements proved to be a fairly tough challenge.
+zhaowenlan1779, with a bit of help from others, implemented this feature in Citra and made it possible to take screenshots without needing any third-party tools.
+With this feature, Citra is now able to save screenshots at any resolution you set (even 10x), and will use the same screen layout.
While Citra has had many hotkeys, they have in the past been hard-coded, and weren’t configurable by end users.
+To fix that, developer adityaruplaha attempted to implement configurable hotkeys by building upon the work done by another developer, Kloen, for the same.
+
Over the duration of a few months, he made multiple attempts to polish the feature implementation, and with a bit of help from other devs, he finally completed it.
+Now, hotkeys are seperated into a new tab, and are fully mappable to keyboard buttons. (Controllers are not supported yet!)
While work on DSP LLE was progressing sluggishly and no one was actively working on audio-related improvements, developer RoadrunnerWMC happened to find a bug in our DSP HLE implementation which was causing broken audio in Luigi’s Mansion - Dark Moon.
+He had a hunch that this could be happening due to incorrect address masking, similar to a bug that had been found in Dolphin some time earlier.
+
He was successfully able to fix the issue in that game, but, as his implementation wasn’t hardware-tested, we at first couldn’t confirm if it was the correct way to fix it.
+His initial fix was to mask away the lowest bit of physical audio buffer addresses, but after multiple hardware tests were run on different consoles, it was found that masking the lowest 2 bits was actually correct.
+This fixed buggy audio in games like Luigi’s Mansion - Dark Moon, The Amazing Spiderman, Metroid Prime - Federation Force, and a few others.
A while back, developer EverOddish came forward and implemented scripting support in Citra using libZMQ.
+While it was a very welcome move and was well-received by the community, unfortunately libZMQ was riddled with building issues.
+The build script for libZMQ was huge, and incompatible with Citra in many ways.
+Also, it seemed to be an unnecessarily big dependency just for scripting.
+
Unfortunately, EverOddish was very busy with other stuff and couldn’t work on rewriting it.
+After waiting for a while, wwylele took over and reimplemented scripting over UDP using the boost asio library, thus entirely removing the libZMQ dependency.
+While the current capabilities of scripting are limited to reading and writing memory at this point in time, we plan to expand this in the near future, so stay tuned!
When developer SachinVin unofficially ported Citra to Android, our own team members BreadFish64 and jroweboy were secretly working on an official port.
+Since the app was based on Citra code a few months old, it was missing many features, fixes, and performance improvements that were present in the latest Citra code.
+This unoffical port also heavily borrowed UI from Dolphin’s Android app, which didn’t fully meet the requirements of Citra.
+
However, since then, BreadFish64 has been working along with jroweboy and liushuyu tirelessly to officially port Citra to Android, with a brand-new UI that’s not based on Dolphin’s code.
+Although the app isn’t ready for public usage, the work is progressing slowly but surely.
+Here is a small sneak-peek of the work-in-progress app.
As a result of collaboration between developers Flame Sage and bscubed, we finally have Flatpak support for both Citra Nightly and Citra Canary builds.
+For the uninitiated, Flatpak is a system for building, distributing, and running sandboxed desktop applications on Linux.
+Flatpak support means that Citra can now be installed and run on virtually any Linux distribution without running into OS-specific issues.
+
Conclusion
+
There’s been other exciting work from many different contributors, and we want to thank them all, but writing articles and blog posts is a very time-consuming process.
+We currently don’t have anyone writing articles on a regular basis.
+If you would like to contribute to the project by joining the writing staff, reach out on the forums or on Discord and show us what you can do.
+
+
+Please consider supporting us on [Patreon](https://www.patreon.com/citraemu)!
+If you would like to contribute to this project, check out our [GitHub](https://github.com/citra-emu/citra)!
+
It has been more than a year since the last progress report, not for lack of progress, but for lack of writers.
+To fill in the gap, developers jroweboy and FearlessTobi independently wrote drafts for a new progress report, and another developer zhaowenlan1779 merged their works and added more content. Together, we are able to present you with an update on all the changes we’ve had since 2019 Q1.
+
Since it has been such a long time since the last one, you may already be very familiar with several of these features, but there are also a few here that we haven’t announced until now!
+
Also, if you don’t know already, Citra Android has already been released! Read this blog post if you are interested.
Adding save states to Citra is a tremendous undertaking that developers shuddered to think about.
+In a modern emulator like Citra, games don’t directly access the hardware anymore, but instead communicate with the 3DS operating system.
+This 3DS operating system communicates with the 3DS kernel, and the kernel will manage all of the very low level communication with the hardware.
+
In retro console emulators, save states usually only need to store and restore the current state of all of the hardware, but in Citra, we have to do so much more.
+Every last operating service and every single kernel object need to be serialized in addition to the hardware state.
+
In total, Hamish edited over 500 files with these changes and there was still more work to do. zhaowenlan1779 helped make a simple UI and the file format for save states. Several developers including lioncash, zhaowenlan1779, B3n30, BreadFish64 and vitor-k also helped by reviewing the code and pointing out errors. Together, we finally got this huge PR to a mergeable state.
+
This is why developers have long feared working on save states, it’s a thankless job where you must dig through every last bit of code in Citra, and decide if it needs to be added to the save state or not, and if you get anything wrong, well, then the game just simply breaks in unexpected ways.
+Tracking down why a game breaks is a nightmare because the root cause of the bug can be failing to restore a single object properly.
+In the best case scenario, the game crashes immediately so we get a good idea of what is wrong.
+And in the worst case scenario, the game doesn’t use that object for seconds or even minutes, until when it finally does and out of nowhere, crash!
+
Since this is so new, you can bet that there will be bugs and broken loads, so we ask for your help in reporting these issues when you find them.
+
New 3DS Support
+
You may have known this already, but New 3DS support has finally arrived!
+
New 3DS support is another highly requested feature for Citra. The New 3DS is a member of the Nintendo 3DS family with upgraded hardware. It has more cores and more RAM, so games can do more computing. There are a handful of New 3DS exclusives, and many more that are enhanced.
+
With the combined efforts of B3n30, FearlessTobi, and many other developers, we are finally able to deliver proper New 3DS support. We see almost all major New 3DS exclusive games booting and running in a playable state. Although not all of them run at fullspeed yet, we hope you will be able to enjoy exploring the huge worlds of Xenoblade Chronicles 3D or fighting some zombies in the (very pixelated) 3DS port of Minecraft.
+
+
+
+
+
+
+
+
+
+
+ Liked the New Citra XL? The functionality was real!
+
The biggest roadblock for New 3DS support was our scheduler. Since most Old 3DS games only used one of the two cores present, we emulated one core, and left the other one basically untouched.
+
This worked for most games, but broke some, even in Old 3DS mode. A long time ago, we tried to mitigate this and other threading bugs with a “priority boost” feature that would run threads that haven’t been run in a long time for a bit. As our scheduling got better though, this hack was eventually removed and some games were just left broken.
+
On the New 3DS, things got even worse. There are 4 cores to be emulated, and our only emulating one of them proved to be even bigger of a problem. Many games required multiple cores to run correctly, and they just refused to boot at all in older versions of Citra.
+
It required quite a bit of work to get the cores in sync while not ruining performance. Developer B3n30 researched the scheduler and stepped up to implement what we call “Core timing 2.0”. He added a timer for each core, and basically rewrote how our timing worked, thus creating a more accurate scheduler. After this change, not only was a big step done towards compatibility with New 3DS games, but it also fixed all the games that were broken with the priority boost hack removed, for instance, Digimon World Re:Digitize Decode.
+
While Core timing 2.0 improved timing accuracy, it also came with performance hits, such as the infamous stutter when entering battles in Pokemon games. One reason for such regressions was that, since there are more cores to take care of, cache invalidation would happen more often and on more cores. MerryMage, author of dynarmic, the ARM JIT we are using, fixed the Pokemon stutters by reducing the overhead of such invalidations. However, some other games still had problems. B3n30 noticed that this was due to the JIT executing smaller slices, and he’s now working to strike a proper balance between accuracy and performance. Some of his changes are already in Canary, so be sure to check them out!
3DS games use “memory modes” to tell the kernel how much memory they would use, and how much memory is left for the Home Menu, applets and services. As mentioned above, the New 3DS has about twice the amount of RAM, so there are also more memory modes we need to support. With the help of other team members, FearlessTobi managed to create an accurate implementation, making it possible for New 3DS games to map the extra RAM as they like.
+
CFG: Let GetSystemModel report model based on Settings:is_new_3ds (#5104) by B3n30
+
After those two changes were thoroughly tested and eventually merged, all we had to do was to inform the games that they were running in New 3DS mode. For the most part this had already been done even before we actually implemented New 3DS support, but there were still some edge cases left unhandled.
+
One of these was the CFG service. Games are able to get lots of information from this service about the console they are running on. As one would expect, this information also includes the model of the system. B3n30 updated the function GetSystemModel so that it would change the return value to New 3DS if Citra is set to New 3DS mode.
+
citra_qt/system: Add N3DS mode checkbox and enable it by default (#5117) by FearlessTobi
+
UI changes are always the last piece of the puzzle for any major feature. FearlessTobi added a shiny new checkbox to the System tab of the configuration dialog.
+
With this, New 3DS mode is now turned on by default for both new and old users of Citra.
This is the unannounced new feature, now available for testing in the latest Citra Canary builds!
+
Download Play is yet another gimmick Nintendo added to the DS, and then passed on to the 3DS family. Download Play allows players to send and receive short demo games. Not only that, some games like Mario Kart 7 use this for local multiplayer as well. In order to get multiplayer support for MK7, we had to take the time to look at this feature.
+
On the 3DS, there is a system module dedicated to Download Play - appropriately named dlp - which games send commands to, in order to communicate over the DLP protocol. This system module is relatively unknown, with almost no documented functions on 3DBrew. Despite this, we know that internally, the dlp module uses another service to send data over local wireless network - nwm::UDS, which is the same service games use for regular local multiplayer. nwm::UDS, on the other hand, is well-researched, and Citra has had support for it for years.
+
We decided that the easiest course of action to get Download Play would be running the dlp module in LLE (Low-Level Emulation) and let it handle commands and call the UDS functions (which Citra emulates in HLE) itself, instead of fully reserve-engineering and reimplementing its code.
+
Back in October 2018, Subv set out to work on DLP LLE. At that time, Citra already had support for LLE-ing system modules. However, considering the fact that Citra was originally intended to be an HLE emulator, it was not surprising that we had some kernel inaccuracies here and there. These issues only surfaced when there were multiple processes running at the same time, and therefore they weren’t discovered until we actually started to run the system modules. We also needed a bunch of extra service functions to be implemented, so that the dlp module can be happy and doesn’t error out. Subv fixed some of them and managed to get Download Play working partially. He published a small patch in the internal channels, so that other developers could test it.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The good old times
+
+
+
+
+
+
Later, B3N30 and jroweboy followed Subv’s instructions, only to get a ‘Connection Failed’ message. They tried multiple times over the period of nearly two years, but still couldn’t make it work. In the meantime, Subv was facing some difficulties in real life, and had to take a break from Citra development. That was why we eventually missed this good chance to get Download Play support.
+
A few months ago, however, a turn of events came. Subv returned from his long hiatus and started helping with Citra again! B3N30 decided to once again pick up DLP LLE, and this time, with the help from Subv, he was able to get it fully working!
+
Instructions on Using DLP LLE
+
Since this is LLE, keep in mind that you need to dump quite a few system files for it to work. In the past, this would mean manually looking through GodMode9 trying to find a bunch of different files. However, thanks to threeSD, a new dumping tool which we will cover later, the hassle is no more!
+
Follow these steps to dump the necessary system files and enable DLP LLE:
+
+
Follow threeSD Quickstart Guide. Remember to manually select System Data > Config savegame in the contents list!
+
Open Citra and click on View > Debugging > Toggle LLE Service Modules in the menu.
Citra is an HLE emulator. Even though we took the easier path of implementing DLP as LLE this time, we likely won’t stop here. With proper reverse-engineering, it may become possible for us to provide DLP HLE support without the need of any system files in the future.
Custom textures allow a modder to completely redo the textures of a game, and really let the games shine in full HD.
+Due to the low resolution of the 3DS, games often used low-quality, compressed images for the models, so when Citra renders at upscaled resolutions, it’s still just not quite perfect.
+
With custom textures, the power to breathe new life into these classic games is now yours, and we can’t wait to see what you do with it!
+To make a new texture pack, simply turn on the “Dump Textures” option, and play through the game.
+As new textures are loaded, they will go into the Texture Dump Location (right click on the game in the game list to open it).
+Simply replace the contents of the dumped images while keeping the name the same.
+
When you are finished, combine all of the new custom textures into a new folder with the GAME_ID as the name, and distribute this folder.
+To use a custom texture pack, right click on the game in the game list and select Open Custom Textures Location. Place the folder with all the textures inside.
+Then, turn on the Use Custom Texture option in Graphics -> Enhancements and you are set to go.
+
The following are previews of some awesome texture pack projects by the community. They aren’t finished yet, but stay tuned! You can also check out the #mods-and-texture-packs channel on the Citra Discord server.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Left: Custom Textures, Right: Original
+
+
+
+
Click here to see a larger version of the above juxtapose.
Tired of waiting for someone to make a custom texture pack for your favorite 3ds game?
+Here’s the next best thing; introducing automatic texture upscaling!
+
With texture upscaling, Citra will use one of several algorithms to automatically upsize the image to a higher resolution.
+Along with the change, Breadfish64 has brought in several high quality upscaling shaders to use.
+
Seeing that some of these shaders don’t work that well with Citra, he even wrote one himself, and it works really great!
+Try it out and see how it looks.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Left: unfiltered, Right: ScaleForce
+
+
+
+
Click here to see a larger version of the above juxtapose.
While original games are great, they often come with imperfections. That is when mod makers can step in to enhance the experience and sometimes add more content.
+
Thanks to zhaowenlan1779 and leoetlino, Citra now has official mod support - just right click on the game in the game list and select Open Mods Location, and put your mod there! Refer to this help page regarding how the mod files should be structured.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ As an added bonus you can now Dump RomFS as well
+
leoetlino, a well-respected member of both the emulation and the modding community, was working on a great new mod when he decided to add the missing modding features to Citra.
+
Firstly, he added support for ExHeader replacement, which allows modders to use more memory and add more code. He then moved on to fix our implementation of IPS patches (originally written by zaksabeast). Not stopping on his mission, he then added support for another type of patches: BPS. The BPS format allows distributing patches that are smaller and that do not contain copyrighted content if data is relocated.
+
Based on leoetlino’s work, zhaowenlan1779 later added more paths for these replacement files and patches, so that they can be used with ease.
+
leoetlino’s changes make it easier for modders to add custom code to 3DS games, so be sure to check out Project Restoration sometime as a thanks for these contributions! For those who don’t know, Project Restoration by leoetlino restores some of the more controversial changes made in the 3DS release of Majora’s Mask back to how it worked in the N64 version, and adds several new improvements to the classic game.
LayeredFS is a technique used by mod makers to replace files in the RomFS (Read-only File System), where game assets and occasionally code are stored. With LayeredFS, you can replace the game graphics, music, etc. without having to rebuild the entire RomFS, which can be huge.
+
Since Luma3DS has had LayeredFS for years, there were many requests for Citra to add it as well. That was why zhaowenlan1779 decided to take on this task.
+
More modern consoles often have high-level FS APIs, which means that the game requests the OS to read files. While this translates to more work for the initial FS implementation, there are also compensations. For these consoles, LayeredFS can be added with ease simply by replacing the data to be returned to the game. For the 3DS, however, things are different. The FS service only provides basic functions to read the RomFS as a huge binary chunk - and the games need to parse the filesystem themselves.
+
Luma3DS’s LayeredFS works by hooking the SDK code the games include to parse the RomFS, but zhaowenlan1779 decided to take a harder and more robust approach. With help from 3dbrew documents, he wrote code to rebuild the RomFS metadata and assign fake data offsets to files. From the game’s perspective, it would seem as if the RomFS has been completely rebuilt, but we are not actually doing that much work.
Do you like it when your game just hangs for a few seconds repeatedly? No? Then this feature is something for you.
+
Stuttery gameplay is a real issue in some games on Citra like Luigi’s Mansion: Dark Moon.
+This game is developed with a very modern approach to GPU hardware and makes extensive use of the 3DS GPU for all of its effects.
+
A shader is a small program that runs on your GPU.
+Whenever the game tells Citra to run a new shader, Citra translates this shader, so that your GPU can understand it. Then, it gets uploaded to your GPU.
+This entire process can take a bit of time, so Citra has to pause emulation until the shader is ready, causing stutter whenever the game is drawing something for the first time.
+
With this change, Citra will now instead preload all the shaders you’ve encountered during gameplay, allowing you to play through those same spots again without any stutter.
Some of you may be wondering: since it is so easy to use OBS to record gameplay, what is the point of a built-in video dumper? Well, while OBS is cool, there are people out there who wish to share their gameplay at consistent speeds without slowdowns and stutters. TAS communitys like TASVideos also required complying emulators to provide a way to ‘render’ gameplay. That was why zhaowenlan1779 implemented a video dumper into Citra around Aug 2019.
+
However, when the dumper was initially added, there wasn’t a proper configuration dialog, and it would always use the VP9 encoder. As VP9 is a CPU encoder, the performance was bad when the resolution got high.
+
jroweboy listed some of the issues with the original video dumper implementation. Later, zhaowenlan1779 decided to fix them. In addition to various general improvements, he also added a new ‘Dump Video’ dialog that will be shown when starting dumping. From there, users can select any format and encoder, and even configure specific options to pass to FFmpeg. This made it possible to use hardware accelerated encoders like NVENC.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Those large DLLs are finally put to greater use
+
+
+
+
+
+
Custom Post-Processing Shaders, Anaglyph 3D and Nearest Neighbour Filter (#4578) by xperia64
+
You read it right. xperia64, a developer of the Drastic emulator, managed to deliver three features in a single PR. For those who don’t know already, post-processing shaders are basically an additional effect added to the final image rendered.
+
It all started when xperia64 set out to implement anaglyph 3D for Citra. However, since Citra did not have post-processing shader support, he had to implement it first. For drop-in compatibility with many Dolphin shaders, he even added some of the Dolphin aliases and bindings.
+
On top of post-processing shaders, he added a built-in red-cyan dubois shader which implemented anaglyph 3D, making 3D effects accessible to more users who don’t really have a 3D screen. While he was at it, in order to fix some of the shaders, he added an option to toggle Linear Filtering. This was previously on by default, and turning it off would get Citra to use Nearest Neighbour Filter mode. It fixed some issues with certain shaders and worked better for some textures, such as game text.
+
You can drop your own shaders in the shaders folder in the Citra User Directory. New flavors of anaglyph 3D can also be added in the shaders/anaglyph folder.
VSync was first added to Citra in 2016, but it was always broken until this change.
+
Citra was originally designed to render the final frame on the same thread that the emulation runs on, so when VSync is enabled, it causes the emulation to pause until the GPU is done displaying the frame.
+This means that any time Citra was even a tad bit too slow, it would pause the emulation until the GPU was ready to draw again.
+At 60FPS, this could mean waiting a whole 16.6 milliseconds until then!
+
With this change, VSync is now on by default, and Citra will be able to continue emulation even while the GPU is drawing the frame.
Most of you may have been familiar with Miis ever since the age of Wii, but on Citra there were a few problems with Miis. For one, you were unable to select any Mii, and would have to live with a default one even if you added your own ones.
+
This was due to the Mii Selector, an applet on the 3DS, being unimplemented. On the 3DS, games call this applet to prompt you to select a Mii, but on Citra, it got skipped, and the default Mii got sent back to the application.
+
vvanelslande (using his old account) made a fix but closed it. FearlessTobi took and improved his code, and finally got this feature merged. No Mii faces are rendered yet, but I think we will agree that it’s a big improvement even if you can only see the names.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ For those who liked the default Mii it is still there
+
Citra decides how much time the game has run on the CPU by counting up the number of instructions the CPU runs.
+Some games take advantage of this extra time and do additional work each frame, which means that Citra can’t keep up and the speed can drop below 100%.
+As a workaround for this, some games that experience a similar slowdown on 3DS hardware will include built-in frame skipping code, letting them do less in a frame if they aren’t going to get full speed.
+
The CPU frequency slider added here allows a user to overclock or underclock the emulated CPU clock speed.
+By underclocking the emulated clock, this can cause games to think that they need to do less work in order to keep full speed gameplay, which means Citra also gets to keep full speed as well.
+By overclocking, it’s possible that the game will no longer need to skip frames, and as long as your Citra is at 100% speed, it may make the gameplay smoother.
+
Either way, this slider should only be used for experiments or workarounds, and we won’t provide support for any bugs caused by changing the slider from 100%.
+If you have a crash when under/overclocking, don’t bother reporting it, just change the setting back to 100% and continue playing.
Being a dual-screen console, the 3DS has a second, smaller touchscreen in addition to the main 3D screen. Usually, games put less important information and buttons there. Owing to the relative low number of physical buttons, however, there are actually a number of games that use the touchscreen for rather frequently used buttons, one notable example being the Ⅰ and Ⅱ item register buttons in OoT 3D. This brought lots of inconvenience when playing on the 3DS itself, and even more when you are hooking Citra to a single-screen monitor or TV, and using a keyboard or a controller.
+
Previously, you would have to rely on third-party solutions which can require complicated configuration. But, this is such a useful feature that z87 decided to work on implementing this. Later, they also made a beautifully crafted visual editor so that you do not have to look up the coordinates manually, making this feature even more accessible. Currently, you can only bind single buttons (e.g. you cannot bind ZR+A to a point), but this will likely be improved in the future.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Get rid of complex external tools with this new, intuitive mapping dialog
+
As a portable console with multiple screens, the 3DS boasts new and innovative game play styles, such as holding the console on its side.
+It’s something Citra didn’t support for years, simply because there were no major games around doing this when the emulator was first written. To be honest, this play scheme was also pretty impractical as you can only access a subset of your buttons.
+
This changed over time as some first party games started to make use of this feature. One example is Mario and Luigi: Dream Team, where “giant combat” requires you to use the touchscreen sideways to fight giant versions of Bowser and his Minions.
+
Seeing the feature request on our issue tracker, vitor-k came around and added the new layout to Citra.
+You can now use this rotated layout by choosing the Upright Book Style mode in the View -> Screen Layout settings.
Where would 3DS emulation be without supporting 3D?
+iwubcode added another way for you to experience the 3DS on a 3D display with stereo interlaced 3D mode.
+Try it out in Configure -> Graphics -> Stereo (Interlaced)
When developing an emulator, it is important to keep track of performance improvements and regressions. Without proper recording mechanics in place, however, the developers could only ‘feel’ the difference. Thanks to BreadFish64 and jroweboy, this is no longer the case. Developers can now get a log of frame times (the time used to render each frame) from which they can generate beautiful graphs for analysis. What’s more, the mean frame time of the play session will now get sent via telemetry, so we can gather even more performance data.
+
Note: This feature is not in the UI, to avoid boasting it with too many menu actions.
General system stability improvements to enhance the user’s experience…
+
On a more serious note, our C++ expert, lioncash has been working hard to fix up minor issues in our codebase. The code is not just cleaner, it should be ever so slightly faster as well! In hot code, every cycle counts.
+
Emulation Accuracy
+
Amiibo
+
nfc: Improve implementation of GetAmiiboConfig (#4688) by FearlessTobi
+
When Amiibo support was added in the last progress report, there were a few known issues that still needed investigation which can cause intermittent Amiibo load errors.
+
One of these issues was caused by missing fields in GetAmiiboConfig. For example, some games check for the series of the Amiibo which, previously, was left uninitialized.
+After extensive HW tests, FearlessTobi improved implementation of the function and properly loaded the missing fields.
+
This fixed Amiibos in Yoshi’s Woolly World, Smash (partially) and probably other games too.
vvanelslande stepped in and debugged another issue and found out that we didn’t update the Amiibo state correctly when loading and unloading them.
+wwylele followed up with this investigation and came up with a solution to the problem that didn’t require modifying the UX.
When wwylele wrote the Amiibo fix above, there was one TODO he left in the code, as it was not clear what the 3DS will do when the Amiibo is removed after data has been loaded. This, however, resulted in a bug where trying to remove the amiibo does nothing in Luigi’s Mansion.
+
Based on observations of game behavior, vvanelslande modified the code to fix the bug. Proper HW tests still need to be done to verify whether the change is really correct, but since this was ‘unknown’ anyway, we decided to accept the fix.
When decoding AAC audio, the decoders use a different audio format than the 3DS, so Citra needs to convert to the 3DS format.
+This caused audio popping in games that used AAC if the conversion wasn’t accurate enough, but thanks to liushuyu the popping is no more.
+
Prevent out of memory errors when the game passes in an improper length value (#5024) by jroweboy
+
In Luigi’s Mansion Dark Moon, when using HLE Audio, the game mysteriously passes in an extremely large value for length, which, without any checks, caused Citra to try to allocate an extremely large buffer.
+
jroweboy took the time to investigate this and concluded that there were some other bugs in our HLE implementation. The game seemingly reads a value from the DSP and subtracts to get a length, without checking for underflow first. He researched the issue fairly extensively but couldn’t find a fix.
+
Since an actual fix would likely be rather hard, he made a temporary HACK to prevent out of memory errors. After all, no matter what we do, we shouldn’t freeze people’s PCs by allocating much bigger memory than they could possibly have.
+
Add sample rate field to AAC decoder (#5195) by xperia64
+
When AAC was added to HLE, it was entirely RE’d from how Pokemon X used it.
+However, while the HLE code worked fine for Pokemon, Rhythm Heaven Megamix sounds much faster than normal. It turned out that it used AAC audio with a different sample rate than Pokemon. By comparing HLE and LLE outputs, xperia64 found out that one of the ‘unknown’ fields in our response seemed to be the sample rate enum.
+
He then did careful tests and calculations to figure out which sample rate each enum value stood for. With this, Rhythm Heaven Megamix now sounds correct even in HLE. (However, the game still has desync issues and is not really playable right now.)
Citra’s audio backends were created to be ‘good enough’ for most games, and weren’t really tested for perfect timing accuracy against real hardware. This turned out to be a problem in rhythm games, which required a perfect match between the audio and the graphics to be playable. xperia64 discovered this issue when playing Project Mirai 2. It was rather worrying, as both HLE and LLE backends were off - but in a different way. The HLE backend would rush ahead, while the LLE backend would fall behind the gameplay.
+
xperia64 looked into the bug, and he turned out to find many hidden inaccuracies in Citra’s timing system!
In the HLE backend, there was a constant which tells how many CPU cycles an audio frame takes. Previously, we used a hardware-measured value, but apparently this measurement wasn’t really as precise as we hoped it would be. xperia64 replaced it with a calculated, theoretical value. This new value reduced the desync in Project Mirai 2 in the HLE backend to about negligible. He later further checked the change with rough hardware tests, and it indeed matched the hardware behavior better.
+
Update FPS to roughly match the actual 3DS rate (#5273) by xperia64
+
While Project Mirai 2 was fixed, other games like Rhythm Heaven still had issues. xperia64 was looking around in the code when he came across this line, which had been present for more than 3 years:
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ … Wait, what?
+
+
+
+
+
+
This meant that Citra’s screen refresh rate was hardcoded to exactly 60Hz! This definitely isn’t true on a real 3DS, where the LCD refresh rate is known to be somewhere around 59.83Hz. With help from profi200, xperia64 was able to take accurate measurements and fixed this long-standing mistake. This turned out to resolve most of the remaining audio timing issues in HLE.
+
Update teakra, adjust TeakraSlice for new audio frame period (#5402) by wwylele and xperia64
+
Now that HLE was fixed, it was time to look into LLE as well. In fact, before the audio desync got attention, wwylele, author of teakra, had already found a problem in his code. A value called transmit period was previously wrongly assumed to be 4100, while it should have been 4096 instead. However, while this fix did correct the overall audio sync, it dropped frames from time to time, resulting in large discontinuities in the audio.
+
It took a while for us to realize that this new issue wasn’t caused by teakra, but rather by Citra itself. When Citra calls into teakra, we need to feed it with a slice length value. This is the count of cycles teakra would run at a time. When chosen inappropriately, the slice could end while audio was still being processed, resulting in the cut-offs observed.
+
Since this value is in fact sort of arbitrary and can’t really be calculated, xperia64 had to figure out a proper value with trial and error. He found that multiples of the transmit period mentioned above appeared to prevent the drop outs, and eventually chose 16384. This, combined with the transmit period update, resulted in a proper fix for audio synchronization in the LLE backend.
A small regression when mipmaps and cubemaps were added to Citra: the combination of these two were not supported.
+In very rare cases, games would use both and cause issues, so wwylele stepped in and made them work together properly in Citra.
Pokemon X/Y are back again causing more problems.
+This time the games exploit a flaw in 3DS GPU hardware when rendering, which is really really challenging to reproduce in an emulator.
+
When drawing certain scenes, the game forgets to configure a texture to draw from, which causes the 3DS GPU to do something weird and use the last drawn pixel color value instead.
+This means proper support for this 3DS “feature” would require determining the precise algorithm the 3DS GPU uses for rasterization to determine what the last drawn pixel is, and that’s quite the challenge!
+
Hamish found that as a temporary work around, Citra can make some scenes look okayish by simply using a clear texture when the game doesn’t choose a texture to render with.
When Hardware Shaders was first added, we had two Accurate options. Accurate Multiplication was relatively well-tested, and we knew it would harm performance quite a bit. However, the other one - Accurate Geometry Shaders - didn’t receive as much attention, partially due to the fact that it was on by default.
+
Geometry Shaders (GS) are shaders processing what are called primitives, which are basically points, lines and triangles passed to your GPU. The PICA had support for programmable GS. Therefore, when we added the PICA->GLSL shader convertor, it was natural to try to support GS as well. However, due to PICA’s weird behaviour of preserving states across shader invocations, it was hard to make an accurate implementation. wwylele put it behind an option, hoping that the rather inaccurate Hardware GS would help increase performance for weaker PCs.
+
When tywald was playing with this setting in MH4U, he discovered that this option actually did the opposite of what it claimed - using Hardware GS (i.e. turing accurate GS off) would decrease performance! With the new performance logging framework put together by jroweboy, the team did further tests and confirmed his observation. Since the Hardware GS was not only less accurate but also slower, we decided that there was no point in keeping it there at all. tywald removed this setting from the UI, and wwylele removed the actual code.
+
BreadFish64 is now attempting to remove the other setting (Accurate Multiplication). He rewrote the function we were using to mimic PICA’s multiplication behavior. As a result, not only was the performance penalty brought down from ~10% to almost negligible, but it fixed Intel GPUs (which were previously having problems with this option on) as well! Hopefully, we will be able to have a clean configuration dialog soon.
Luigi’s Mansion Dark Moon is a problem child for performance on Citra.
+As such, the player base for the game was always very small, and so it was very easy to forget that the game actually had a few major bugs which would crash Citra.
+
The old saying can be very true at times: the squeaky wheel gets the grease.
+So lately, as Citra’s performance improved and Nintendo released a new Luigi’s Mansion game on the Switch, it brought a lot of attention to this title, and the users clamored for a fix.
+
In this title, when drawing an effect for a certain ghost, the game would copy extra bits into an address field which tells the 3DS GPU where it should load the data from.
+In Citra, we accidentally read these extra bits, which caused Citra to read way out of bounds and crash.
+The fix is one small line, change the number of bits Citra reads to cut out those extra bits.
Emulating the 3DS’s GPU is hard, partially thanks to dumb games. On newer consoles like the Switch, games would usually use established graphics API such as OpenGL, so their behavior is mostly reasonable. On the 3DS, however, it seems that games are really trying their best to make use of all kinds of strange features and exploit all edge cases.
+
On the 3DS, games have the ability to access cached surfaces with different formats than what they were originally uploaded as - and they love to abuse it. On Citra, however, due to limitations of modern APIs, we simply cannot do this in the same way as the 3DS. Without a format convertor, we would have to reupload the surface from CPU memory to the GPU - and this was really slow. For instance, the after-match screen in Smash 4 got affected horribly.
+
jroweboy made a hack (#4089) to ignore these reinterpretations to improve performance. It turned out that this worked fine for most games, but broke Paper Mario and about all VC games. Since this was a hack anyway and he knew that a proper implementation would be possible, he eventually decided to close it.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The stickers mysteriously disappeared from the bottom screen
+
+
+
+
+
+
So, what was the proper implementation? Using shaders on the host GPU to actually convert the surfaces. In fact, we had done this already for a specific case (RGBA8 -> D24S8) but there were many other convertors missing. B3n30 created the original Format Conversion PR (#4902) based on jroweboy’s work. That PR did not add any new convertors, but laid the framework for them, and he also added a log so that we can collect information regarding which convertors were necessary.
+
As it turned out, most of the conversions the games are trying to do didn’t even make sense. For many of them, the pixel sizes of the formats didn’t match - which meant that the surface would take up different amounts of memory before and after conversion. They were basically impossible to implement and practically useless as well. After further analysis, we decided that they were simply games reusing memory, and ignoring the reinterpretation for these would be fine.
+
The VC games did have a valid use case though (RGBA4 -> RGB5A1), and BreadFish64 implemented this convertor. With this, we were finally able to get proper Format Reinterpretation that improved speed while not breaking any games.
While we usually try to make games go as fast as possible, there are also times we need to intentionally put delays. File I/O is a good example.
+
On a real 3DS, Super Mario Maker would take quite a while to create the huge Extra Data on the SD Card - about 3 minutes! On Citra, this process finished instantly - only at the cost that the ‘Creating Extra Data’ scene would loop forever. wwylele discovered that sleeping the thread for a very short period would fix the issue.
+
We then measured and added a delay of 39000ns to all IPC (Inter-Process Communication) calls - but as it turned out, this didn’t fix the issue. The reason was quite obvious: I/O operations take much longer than your average IPC call.
+
FearlessTobi wrote a few homebrews to measure file I/O delays for different file sizes. He then did a simple linear regression and put the formula in Citra - and it worked perfectly! While there are some other file types where the delay hasn’t been measured yet, for the most part this should be sufficient.
For local wireless play, games are expected to use the UDS system service on the 3DS, but there’s actually two UDS services, an old version and a new version.
+
When Citra added multiplayer support, we only added the new version which almost every game uses, but there are a few that still use the old version.
+wwylele cracked open the disassembler and looked inside to see what Nintendo does differently between the old version and the new version…
+… and it turns out they are almost exactly the same!
+
With a few tweaks, wwylele made the old version use our implementation of the newer one.
+This made several old version multiplayer games get further towards supported multiplayer, but sadly they still aren’t playable yet.
Camera support had been there for over two years, but some of the naughtier games still refused to show the camera image. As the original author of the camera integration, zhaowenlan1779 finally decided to look into this. Looking through the IPC calls, he discovered that the so-called ‘Vsync interrupt events’ were missing completely.
+
After performing HW tests, he properly implemented these events, and now camera is working in almost every game.
While most games saved correctly on Citra, there were a handful of games that always complained about corrupted saves. After testing, Dragios discovered that they were caused by a regression in a seemingly unrelated PR over two years ago.
+
When comparing save files from Citra and a real 3DS, zhaowenlan1779 discovered that their sizes didn’t match. After debugging for several hours, he finally found the culprit. In the PR mentioned above, a variable was added to keep track of the file size. However, when games append to the file, that field wasn’t updated. This meant that, if the game ever tried to append twice, previously written data would get overwritten! Updating the file size on write fixed this.
+
This simple change turned out to fix several games with saving issues, including Angry Birds trilogy, Sudoku by Nikoli, WWE All Stars and others.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ You no longer need to be Angry you lost your progress
+
+
+
+
+
+
service/ldr_ro: Fix CRO loading when the buffer contained multiple VM areas (#5125) by zhaowenlan1779
+
The game “Mario Sports Superstars” didn’t receive much media attention after its launch, mainly because of the release date being just a few days after the global release of the Nintendo Switch. On Citra, it had an interesting issue though: when you tried to load Golf or Tennis, the game would crash and throw you back to the Citra menu.
+
Since the country was on lockdown, zhaowenlan1779 decided to look into this. He soon discovered that there was a bug in our VMManager (Virtual Memory Manager) that prevented the game from allocating enough memory to load CROs. The VMManager manages virtual memory areas. From the game’s perspective, two adjacent memory areas of the same permission and state should be the same as one continuous area. However, on Citra this wasn’t quite the case. By fixing this edge case, the game would now work correctly, albeit slowly.
We have always had the dream of getting Home Menu running on Citra - and Subv is now working to realize it! As the Home Menu needed many unimplemented APT functions, he decided to implement them first.
+
Home Menu still doesn’t work right now, but we are at least a few steps closer!
+
Stubbed GetSdmcArchiveResource and GetNandArchiveResource (#5213) by Subv
+
These two functions are used by games to query the state of the SD card and NAND. Previously, they were unimplemented, leading to games thinking that the SD card wasn’t inserted and refusing to create Extra Data.
+
A simple stub was enough to get these games to create Extra Data properly and go in-game.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ It is now happy with the emulated SD Card
+
+
+
+
+
+
Make GetFreeBytes return a more accurate value (#5282) by FearlessTobi and others
+
Games can use service functions (GetFreeBytes) to query the free space of their save data archive and then do calculations with the returned value.
+When we first implemented this function, we thought that ‘hey, bigger sizes are always better!’ so we told the game they have 1GB free space in their save data. While this worked fine for most games, Fractured Souls wasn’t happy with such a large value. After investigation, we found that this value caused an integer overflow in that game, resulting in a softlock when accessing save data.
+
The fix? returning a smaller value. FearlessTobi chose 32MB. According to wwylele, the biggest observed save size for 3DS is 1MB, so this new value should leave plenty of room, even if games use a bigger size.
+
While it turned out to be a simple fix, the investigation took quite a bit of time. Thanks, xperia64, Subv, wwylele, Hamish and B3n30.
On a real 3DS, the Circle Pad was rather stiff, and it is hard to move it fast. On Citra, however, you can map the Circle Pad to any controller you’d like to use. Most of the time the analog sticks on controllers are much more flexible; if you mapped the Circle Pad to your keyboard, you can even ’teleport’ it with a single key press, achieving what is in fact impossible on a 3DS.
+
While this is rather convenient, as usual some games didn’t like it. This includes Theatrhythm: Curtain Call, where input can be missed if you use the keyboard or even a DualShock 4. The same bug can be observed with Luma3DS’s Input Redirection support. For a long time, this rendered the rhythm game virtually unplayable.
+
Annoyed with the issue, xperia64 decided to fix this. He did so by ‘interpolating’ the Circle Pad values. This means that the Circle Pad will no longer ’teleport’ in a single frame, but will rather slowly move to the latest value within multiple frames. This can cause some minimal input latency, but this is what would happen on a physical 3DS as well (you can’t move your Circle Pad that rapidly!).
The 3DS has a standard keyboard that games can elect to use if they choose not to make their own.
+This keyboard boasts a lot of features that almost no games use, such as a custom dictionary for word suggestions, and as in this fix, a custom callback for validating input. Some games use this to check whether the name contains bad or forbidden words, and they will softlock if they don’t receive the call. Using ctrulib code as a reference, zhaowenlan1779 implemented this feature. This fixed a few games such as Puzzles and Dragons Z.
+
Later, zhaowenlan1779 fixed a regression in the initial implementation, which somehow went undiscovered for a rather long time.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The game can finally hear your name instead of asking again and again
+
Determined to iron out every last bug in the implementation, zhaowenlan1779 moved on to investigate another bug related to the keyboard. In Harvest Moon, the Software Keyboard didn’t quite work - the game would act as if you canceled out even if you clicked on OK.
+
The reason? Originally Citra would clear out the memory used to communicate between the game and the software keyboard, but it turns out the real 3DS doesn’t do this, and some games reused the data already in the memory region.
+Simply not clearing the memory was enough to fix Harvest Moon.
All good things come in threes. Probably that was the reason why zhaowenlan1779 made another small fix to the software keyboard. When the keyboard was first implemented, there was a misunderstanding regarding one of the filters (the DIGIT filter) the games can use. In Citra this filter was preventing all the digits you type, but on a real 3DS it only limits the use of digits to a certain number (specified by the game).
+
This fixed the issue where you can’t type any digits in Monster Hunter 3 Ultimate.
Ever since Software Keyboard support was first added, we have been receiving reports that some of the button texts don’t show up. However, since no one provided a reliable way to reproduce the issue, we eventually lost track of it.
+
With the Android release, however, this problem had become more severe. Not only were the button texts missing, but the buttons themselves disappeared as well! This led to SutandoTsukai181’s coming around and researching the issue. With help from wwylele, they were able to fix this long-standing bug.
+
+
+
+
+
+
+
+
+
+
+ Where is the OK?
+
+
+
+
+
+
Debugging
+
You may not be exactly excited about debuggers, but developers use them every day to figure out why game crashes or hangs. Therefore, better debuggers mean that games get fixed quicker and new features get implemented more easily.
IPC (or Inter Process Communication) is how games communicate with the 3DS operating system.
+Citra emulates the 3DS operating system at a high level, meaning we recoded the entirety of the operating system from scratch.
+With the IPC recorder, developers can now track every call games make to Citra, which has proved really useful for developers trying to figure out why games break.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ This may not seem interesting to you, but it is what led to many of the fixes!
+
GDB Stub is a feature that lets you use GDB (a popular debugger) to debug applications running on Citra. It would be very useful for homebrew developers and Citra developers alike… if only it worked.
+
Citra’s gdbstub has a reputation for being broken. What we didn’t expect was that, it was slowly getting more and more broken over time as no one was using it.
+Here, we listed some of the fixes to the gdbstub over the last year, but we know there are still many more issues. Honestly, the best path forward is probably to rewrite the stub completely.
+
Add program counter in unmapped memory access log messages (#5149) by badda71
+
For homebrew developers, emulators have always been a useful tool for quick testing. However, without a proper gdbstub, it can be hard to figure out why their applications are broken. Among the most common errors experienced are unmapped memory accesses, so badda71 added PC (Program Counter) in the log there to help debugging these errors.
+
Show the threads process names and ids in the WaitTree widget (#5201) by Subv
+
The Wait Tree is a debugger that tells why threads are hanging. Previously, the widget only showed the thread name, but not the process. This worked fine for most cases, but when it comes to LLE applets/services, there are multiple processes running. It’s useful to finally be able to view which process each thread belongs to.
Some users reported that when closing Citra while in fullscreen mode, on the next launch it would be stuck in fullscreen and couldn’t be closed.
+A quick patch later, and all those stuck in fullscreen are now free to see the lovely Citra window as it was always meant to be.
Windows might get a little tired and fall asleep if all you do is game on Citra with a controller.
+This quick patch tells Windows that while a game is running in Citra, it shouldn’t fall asleep automatically.
When installing CIA files in Citra, they contain much more than just the game. Usually, they also include things like the manual, the Download Play version of the game, and a lot of other data.
+
Steveice10 added a simple check to the game list to see if the files installed are game files or other things, and now Citra hides anything that isn’t a game.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Citra can’t even load these files anyway, so why show them?
+
Have a need to load the Amiibos as effortlessly as possible?
+Thanks to vvanelslande, you can simply drag and drop them on the Citra window and have them load!
AAC audio decoding is a constant thorn in Citra’s side, since we can’t legally ship an AAC decoder without paying licensing fees, we had to get creative.
+Many operating systems already pay for AAC licensing and offer APIs that developers can use to decode audio.
+
MediaFoundation is Microsoft Windows’s media encoding/decoding framework, and Citra uses it on Windows for audio playback in a few titles, most notably Pokemon X.
+But it turns out not every edition of Windows 7 and Windows 10 ships with MediaFoundation, and Citra would simply crash when trying to run on these systems.
+As a fix, we now detect if MediaFoundation exists when loading a game, and if it doesn’t, we simply fallback to no audio.
Disk shader cache loading times can get to be really long if you start to have too many shaders.
+jroweboy made a custom loading screen so that you can rest assured Citra didn’t crash.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Adorable, isn’t it?
+
+
+
+
+
+
Show an error if CIA content is encrypted (#5130) by B3n30
+
CIA files can be encrypted. Not only that, the contents of the CIA files can also be encrypted, and these two are separate layers of encryption. Previously, we only showed an error if the CIA file itself is encrypted, so for those with decrypted CIAs of encrypted contents, the behavior would be pretty puzzling. Citra would report that the CIA was successfully installed, but nothing would show up in the game list as the installed contents are encrypted.
+
Since we are getting more and more such reports, B3n30 decided to make a fix. Now Citra errors out if the contents installed are encrypted, making the experience less confusing.
+
Note that Citra does support encrypted CIAs and games, but you will need to provide the AES keys for them to work correctly.
It is annoying to have a mouse cursor on your screen, especially if you are playing in fullscreen mode and with a game that doesn’t use the touchscreen at all. To save you the hassle, vitor-k added this simple checkbox that hides the cursor after 3 seconds of inactivity.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Say goodbye to the annoying cursor with this new option!
+
A bug as old as the rest of the code base. No one seemed to notice that on certain Linux systems, the icon was missing.
+Simply pointing to the correct location for the Citra icon, fixed possibly Citra’s oldest and most forgotten bug.
+
GUI: fix minor issues with dark themes + rename and reorder themes (#5077) originally by Simek
+
In a word - the dark theme now looks better. Also, have you noticed that the themes have been renamed? They are now called ‘Light’, ‘Light Colorful’, ‘Dark’ and ‘Dark Colorful’. More consistent, huh?
+
citra_qt: config: Move audio to its own tab. (#5079) originally by bunnei
+
We have some important Audio settings, make them more discoverable. But do we? Nonetheless, it’s nice to keep the UI of the sister projects as consistent as possible.
While dumping games isn’t exactly too hard, it can be rather annoying. The 3DS has poor CPU and I/O speeds, and therefore dumping can take a long time, especially if the file is large. What’s more, you need to switch between different tools and dump each file one by one.
+
So zhaowenlan1779 decided to create a tool to make dumpers’ life easier. threeSD is written to help import data from a 3DS SD Card. Using threeSD, it is very easy to import everything at once, including applications, updates, DLCs, save data, extra data and the necessary system files.
+Note that, you still need to use older methods to dump cartridges and cartridge saves.
+
This new tool has been added to the wiki pages. Try it out now!
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Dumping has never been so easy!
+
+
+
+
+
+
Conclusion
+
It’s been a great year for Citra, and we are very glad to be able to work with and learn from so many awesome contributors.
+There are always many more ways to improve, and contributions are always welcome.
+
If you’d like to contribute, hop in our Discord or IRC (freenode #citra-dev). If you can’t contribute code, consider subscribing on Patreon!
+
We are also looking for blog post writers! Reach out to us on Discord if you are interested.
Welcome back to another Citra Mega Progress Report!
+
Yes! We aren’t dead! First off, we do apologize for the wait, we are still lacking a full-time writer.
+In the meantime, Citra community moderator autumnburra and developer FearlessTobi have come together with the assistance of another community moderator, SleepingSnake, to provide you, the Citra community, with this awesome report on all the changes we’ve had in Citra since 2020 Q2!
+
If you have been keeping up to date with messages posted in the #development channel in our Discord server, you may already be aware of some of these. But nevertheless, this is a read that you’re not going to want to miss out on!
Following on from the built-in video dumper, mentioned in our previous Progress Report, zhaowenlan1779 provides some much needed versatility for your video recordings and TAS recordings!
+
The changes include features such as adjusting the emulation speed and being able to sync-robust save states when rerecording. Sync-robustness is the concept that if a save state is launched a certain number of times, it should behave the exact same way each time. Being able to use rerecording in an emulator is key when wanting to create TAS videos! Rerecording is used for the validation of TAS scripts, which are used to get the most optimized speedrun of a game.
+
This PR implements many basic rerecording features, following the TASVideos requirements and desired features for a rerecording emulator, but also adds other needed features for our built-in video dumper such as separate save state slots for each movie, adding a read-only mode, fixing desync and file corruption bugs, and also remaking the UI to be squeaky clean!
+
To utilize the rerecording features, head to Tools -> Movie to record your game as a .CTM (Citra TAS Movie) file. These .CTM files can then be played back from within Citra to use for TAS runs.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Implement Reverse Interlaced 3D (#5580) by oneup03
+
Interlaced 3D is a method of displaying stereoscopic 3D content on passive 3D supported monitors and TV screens. This was first implemented in Citra in 2019 to provide more ways to view 3D on a wider range of devices. However, some monitors, such as LG OLED 3DTV’s, render each eye in a reverse order from typical interlaced monitors.
+This PR implements a new way to view the 3D capabilities on a new type of screen, keeping the 3D novelty of the 3DS that so many of us love alive.
+
This setting can be found in Emulation -> Configure (Citra -> Preferences on MacOS), inside the Graphics tab. Make sure to set the Depth to 100% to utilize this feature.
Citra stores the SDMC and NAND folders in a standard user directory location, which is typically located on the same drive as your operating system. The SDMC folder houses your installed games, updates, DLC, and save data, which can quickly accumulate and become large in size depending on your game library. The NAND folder emulates the 3DS’s memory chip and contains the system archives and shared fonts of the 3DS, which can be dumped from your own console. However, Citra has its own open-source implementation of these files that comes with every installation of Citra.
+
Because the user directory is typically not changeable, users who have limited storage space on their primary drive can encounter issues. This PR solves this problem by allowing users to specify a custom location for the SDMC and NAND folders. Adding this was a big feat, requiring the assistance of multiple developers.
+
The initial implementation by nieldm saw slew of other issues, such as internal issues with the custom paths and every user being accidentally forced to use custom directories for SDMC and NAND! All of these issues were ironed out by the joint effort of our developers and we’re proud to say that custom directories for SDMC and NAND are here to stay!
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Start abstracting the rasterizer cache from OpenGL (#6013) by GPUCode
+
As we are entering the mid 2023’s, Citra is long due for a makeover!
+First on the list of things to make Citra shiny again is to polish up our OpenGL graphics backend.
+
A fundamental part of Citra’s renderer, regardless of the graphics API used, is a component known as the rasterizer cache, which is responsible for tracking all memory reads and writes to the emulated 3DS VRAM. The rasterizer cache is Citra’s version of the texture cache, a concept well known to avid emulation followers.
+
But why is this needed?
+To answer said question, we need to look closer into the architecture of the 3DS. It, alongside other Nintendo consoles of the era such as the Wii, uses a unified memory architecture (UMA), allowing both the CPU and the GPU to access the same memory region. Your computer, on the other hand, works much differently; the system RAM is separate from the video RAM. Access to system RAM from the CPU is relatively fast, something that’s not the case when it comes to video RAM. The latter can also be accessed by the CPU. There’s one problem though; doing that is very slow.
+
The main function of the rasterizer cache in Citra is to keep textures in the host VRAM, in the computer’s GPU, so that the renderer can access them quickly while also keeping the host VRAM in sync with the emulated 3DS VRAM. This is particularly necessary for resolution upscaling. As an example, if you had to upload a 2560x1400 texture each frame, the performance would be terrible!
+
In the past, this rasterizer cache was tied with OpenGL and used OpenGL methods directly. This PR introduces a class called TextureRuntime. This is used to abstract away texture operations from the rasterizer cache. By doing this, it allows for other graphic APIs to be easily ported over to Citra, which we will get into later in this report.
.3gx plugins are executable files that are mapped into memory and executed when the game process runs. When the game runs, the .3gx plugins also run simultaneously in a new thread, which grants it the same access rights as the game. This allows developers to expand the behavior of games in a way that would normally be impossible, such as with an Action Replay code.
+
Using .3gx plugins is another way to add that extra customizability to your 3DS games in a way that the unmodded 3DS can’t do. Many projects use these plugins, such as the Mario Kart 7 modpack CTGP-7.
+In the past, due to Citra not supporting .3gx plugins, a “lite” version of this modpack was offered to Citra players. But this came with nowhere near as many tracks and features as the main modpack! The addition of this plugin loader grants Citra users with more modpacks to alter your game in more ways than before.
+
Plugins are loaded from the emulated 3DS SD card. Citra follows the same path as the Luma3DS 3GX Plugin Loader to apply .3gx plugins. Instructions for launching .3gx plugins can be found on our Game Modding page.
If you hadn’t seen in our previous Progress Report, Texture Filters were added to Citra!
+With texture upscaling, Citra will use one of several algorithms to automatically upsize the image to a higher resolution.
+
Nearest Neighbour is a texture filter which is particularly effective at making text stand out and look bolder! With the addition of another highly requested texture filter, you can have more control over how your gameplay looks than ever before!
+
All of these texture filters, including our shiny new Nearest Neighbour texture filter, can be found in Emulation -> Configure -> Graphics -> Renderer in Citra! (Citra -> Preferences on MacOS)
Based on an older PR which never saw the light of day, this PR improves our custom layout handling to support a “picture-in-picture” style of displaying the two 3DS screens.
+This enables you to have two screens overlapping one another to fit within one cohesive view, which is especially useful when in fullscreen.
+
The screens can be swapped using the F9 hotkey within Citra, which allows for a choice of which screen is the main screen and which is the secondary smaller screen. The secondary screen is also slightly transparent, ensuring that the main screen isn’t completely covered up!
+
This PR was first created by djrobx, however as their initial PR never got merged, SomeDudeOnDiscord brought the changes up to master and ensured that this feature was finally implemented into Citra!
In the past, to configure your controller you were required to manually map every single button and joystick direction. This proved to be a tedious activity and would eat into time that you’d rather use playing games! vitor-k implemented a way to automatically map your controller to Citra with the press of a button, provided that your controller is listed in the SDL Controller Database.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Automatically bind your controls with ease.
+
+
+
+
+
+
Disable HIDAPI drivers due to compatibility problems with certain controllers (#5123, #5179) by vitor-k
+
The change of SDL2 from 2.0.8 to 2.0.10 broke some controllers that reported themselves as a Switch or Xbox One controller, such as DualShock 4 controllers. This PR disables the HIDAPI drivers to allow affected controllers to work again. HIDAPI drivers were enabled again for SDL2.0.12 and up in a later PR.
+
Implement official GameCube adapter support (#5735) by epicboy
+
Ported over from yuzu, with code and feature improvements thanks to german77 and lioncash, this adds a whole new input device to Citra for you to use! With the official GameCube adapter from Nintendo, you can now use the classic GameCube controllers to play your favorite games on Citra!
+
Instructions on how to set this up can be found on the yuzu FAQ.
+
Add support for SDL controller accelerometer/gyro events (#5851) by flibitijibibo
+
Following the release of SDL 2.0.14 came support for motion controls, something which had been anticipated for many years in SDL. In Citra, this can be used as an alternative to mouse controls or CemuhookUDP. This is a big benefit to many users, as setting up Cemuhook can be tedious and outright confusing at times.
+Setting up SDL motion controls is as easy as pressing a button! (No, seriously. That is all you have to do.)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Motion controls at the press of a button!
+
+
+
+
+
+
Android
+
If you missed the last announcement, this is a follow up to our previous Citra Android Update!
+
Our Google Play Store release is outdated at the moment due to Google’s new storage permissions system, but we are still updating Citra Android! Builds can be downloaded from our Nightly repository for the time being. We will update Citra Android on the Google Play Store soon.
+
To use all of these brand new features for Android, make sure you have downloaded and installed the latest .apk from our Nightly repository. Keep in mind that these manually downloaded builds won’t update automatically!
Arguably one of the most anticipated and requested features for Android is finally here!
+
A shader is a small program that runs on your GPU. Whenever the game tells Citra to run a new shader, Citra translates this shader, so that your GPU can understand it. Then, it gets uploaded to your GPU. This entire process can take a bit of time, so Citra has to pause emulation until the shader is ready, causing stutter whenever the game is drawing something for the first time.
+
First implemented on Citra Desktop back in January 2020, the disk shader cache has proved to be very effective in reducing stutters over time for all games.
+
By using a disk shader cache, Citra can save these shaders when they are first generated, then preload them on any subsequent launch of the game, eliminating stutter. It was only a matter of time before this was implemented on Android for the benefit of all our Android users, and thanks to SachinVin this has been achieved!
Just to keep things tidy for developers on our GitHub page, many commits from the now defunct “citra-android” repository have been backported to our main repository, affectionately just named “Citra”. By doing this, future development of Citra Android has become more centralized and will hopefully steer developers new and old in the right direction.
For a long time, if you wanted to add cheats in-game, you needed to do this manually by editing a text file containing the cheat code(s) in the Citra User Directory. This proved to be a complicated way to do things, especially when taking Android’s file management systems into consideration.
+
Fans of Citra had been begging for an intuitive way to add cheats to their favorite 3DS games. JosJuice, a developer for the GameCube and Wii emulator Dolphin, stepped up to the task and added a cheat GUI based off of Dolphin’s own implementation!
+
A hurdle in development was found instantly, though. If you slid a panel away while focused on a text box, such as the cheats text box, the keyboard would stay open without an option to close it! This would be frustrating, and require a restart of Citra to get rid of the keyboard.
+With a fix ported over from Dolphin, originally written by t895, the keyboard now closes automatically, as intended!
+
The new cheat menu allows you to input the cheat name, the cheat itself, and any notes about the cheat you would like to add! The cheat menu can be accessed from the in-emulation menu to add, modify, and delete your cheats. However, cheats cannot be disabled while in-game. You must reboot your game for any changes to the cheat code to take effect.
Custom Textures are a powerful tool that allows modders to enhance the texture quality of a game, resulting in even more visually stunning gameplay. Due to the low resolution of the 3DS, games often used low-quality, compressed images for their models, so when Citra renders at upscaled resolutions, they can appear less than perfect.
+Texture Dumping is a simple process that allows you to collect all the textures from a game while you play through it. No need to do anything fancy, all you need to do is play! These dumped textures can be used for archival purposes or to create your own Custom Texture Packs, which can then be added back into Citra to enhance the gaming experience.
+
Added to Citra Desktop all the way back in November 2019, first time contributor LevithaninWaves tasked themselves with implementing this feature for our Android build.
+
To add Custom Textures to Citra, navigate to Internal Storage -> citra-emu, create a folder called load, another folder inside that called textures, then a folder named the TitleID of your game. These TitleIDs can be found on the 3DS releases database if you do not know it.
+Place your custom textures inside this folder with the TitleID of your game. Dumped textures are stored in Internal Storage -> citra-emu -> dump -> textures.
+Both Dump Textures and Custom Textures can be enabled in Settings -> Graphics -> Utility
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Games can now be experienced with improved clarity thanks to this!
+
+
+
+
+
+
Add internet permission to Android manifest (#6167) by PabloMK7
+
This addition is basically what it says on the tin. Some homebrew apps require internet access to download data needed for them to work correctly, such as the Mario Kart 7 modpack CTGP-7. As this is what is known as a “normal permission” granted from Android, any users of Citra do not need to agree to any additional privacy policies that may have been introduced due to this.
+
NOTE: This PR does not mean that Citra Android has multiplayer access. It is only related to homebrew apps at the moment.
+
Allow opening in-emulation menu by pressing Back (#6248) by JosJuice
+
The recent release of Android 13 on some newer devices has caused significant problems with Citra’s user interface. No longer could you swipe down from the top to open the in-game menu. Instead, just the phone notification bar would be brought down.
+
Due to this, you could no longer access Save States, Amiibo, Screen Layout, Overlay, FPS counter, and more. This has made it difficult to fully utilize Citra’s capabilities on devices running Android 13.
+
The solution was to use the back button found on all devices to open the in-emulation menu instead! This can be accessed from the bottom of the device, next to the Home and Recents button. The in-emulation menu is accessible on a number of devices now, such as Chromebooks running Citra Android and VR headsets, not just devices running Android 13.
This PR allows for controls introduced by the New Nintendo 3DS to be utilized in Citra while New 3DS mode is enabled. The New Nintendo 3DS came with the addition of the C-Stick, and the ZL and ZR trigger buttons.
+These can now be used in Citra in games such as Super Smash Bros. for Nintendo 3DS to give you more control over how you play your game!
+
Initial implementation of partial_embedded_buffer_dirty handling (#5548) by xperia64
+
For a while, the Mii voices in Tomodachi Life would constantly cut off before they would finish speaking, which could make it hard to understand what they are saying to the player. By implementing a partial embedded buffer, this being an area of memory which stores data on a temporary basis, you can hear the sweet voices of your favorite Miis again!
+
This also fixes an issue where FMVs in Detective Pikachu would run faster than what the frame rate allowed for.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Make sure to take your hayfever medicine, Frank!
+
This partially fixes an issue where some games would show black and white screens when launched. By implementing Deliver Args, a way to pass arguments from one 3DS application to the another, as well as PrepareToDoApplicationJump and JumpToApplication APT services, this allows the game to crash with a fatal error instead of just hanging on a black screen.
+
This is a step in the right direction for getting these games, such as Sega 3D Classics Collection, to boot correctly on Citra in the future.
+
gl_rasterizer_cache: Remove all fully invalid surfaces from the cache (#5710) by BreadFish64
+
The dead weight of fully invalid surfaces being held in the rasterizer cache impacted many cache management functions and texture lookup times, which in turn lowered performance on some games, such as Pilotwings Resort.
+
By removing all fully invalidated surfaces and implementing a map of recycled textures from destroyed surfaces to avoid driver overhead from allocations, performance on poorly behaved games has greatly increased.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ A great boost in performance for problematic games!
+
+
+
+
+
+
Add svcGetSystemInfo 0x20000 to get Citra information (#5955) by PabloMK7
+
svcGetSystemInfo is used by 3DS applications to gather the information of a system, such as whether someone is playing on a 3DS or 2DS, and to communicate this information back to the application. Homebrew apps also use this for the same purposes.
+As homebrew apps had no way of telling whether they were running on hardware or on Citra, this implements a way for those aforementioned homebrew apps to finally tell if they are being run on Citra or not!
+
Allow MemoryRef to hold a past-the-end offset (#6141) by vitor-k
+
In the past, Citra faced a problem where any copies or operations held at the end of the emulated VRAM were not understood correctly, causing them to be completely ignored. This would cause numerous errors in the emulation of games, including some graphics being cut out entirely on HarmoKnight.
+
By allowing MemoryRef, a wrapper over a pointer to physical memory used for serialization, to hold a past-the-end offset, these values can now be correctly understood and executed. This means that the errors previously experienced due to ignored values will be resolved, leading to a more accurate and improved emulation of games on Citra.
arm/dynarmic: More accurate cycle counting (#6194) by merryhime
+
While most games easily run at full speed nowadays, a long standing issue in Citra has been pre-rendered cutscene videos running way too slowly. This has always been a bit of a mystery, since decoding a video at a resolution of 240p shouldn’t be too taxing on the system of an average user.
+
By implementing more accurate cycle counting, we are happy to announce we have made the first step towards solving this problem, improving FMV video performance by up to 3x! To understand what this means, we need to take a closer look at how a processor works.
+
On the lowest level, all that a CPU does is process a list of instructions. Some instructions however take longer to execute than others. The time it takes for an instruction to execute is measured in cycles. Previously, we were using a very naive implementation of assuming every instruction would take one cycle. This leads to games idling longer than they should, therefore unnecessarily slowing down the emulation.
+Now merryhime, the author of dynarmic, has implemented much more accurate cycle counts, significantly reducing this issue. Performance is still problematic due to currently unknown reasons, so please expect FMV videos to run at half speed on hardware that only meets our minimum recommendations.
+
Multiplayer Fixes
+
APT: implement Set and GetWirelessRebootInfo (#5328) by B3n30
+
This PR implements two key services relating to Download Play Applet functionality on Citra. SetWirelessRebootInfo and GetWirelessRebootInfo are used to transfer information and arguments between reboots of Download Play. These are necessary so that the app is able to start another app, like in the way Download Play works via transferring a game demo from one console to another. Download Play does not work in Citra just yet. This PR is just to lay the groundwork for it to hopefully work in the future!
+
NWM_UDS: Implement disconnect_reason and EjectClient (#5331) by B3n30
+
The implementation of disconnect_reason and EjectClient is required to be able to disconnect from a multiplayer session correctly if the host chooses to terminate the room or force-disconnect clients. This allows for multiplayer to work correctly in certain games, such as the Monster Hunter series.
This PR is just a minor fix to multiplayer in the Monster Hunter games, specifically Monster Hunter Generations, Monster Hunter X, and Monster Hunter XX. These games would suffer from crashes and disconnects when players tried to join a lobby. Now, with this fix, you can go out and hunt your favorite monsters with your friends again!
+
Remove citra-room dependence on core (#5519) by vitor-k
+
With some reorganization of the code, we were able to reduce the size of the citra-room executable by 85%, decreasing citra’s compressed size by 6MB and uncompressed size by 43MB!
+Those who host rooms with citra-room will also no longer need to have OpenGL support on their machines.
By implementing GetApplicationData, an issue is resolved in which multiplayer communications would only work one way in Dragon Ball Fusions. This change also fixes multiplayer altogether in Final Fantasy Explorers. GetApplicationData is used to load appdata from the current beacon, which can then only be used while connected to the network.
+
service/frd: return cfg username on GetMyScreenName (#5792) by vitor-k
+
When playing multiplayer games, it is helpful to be able to identify your friends. But previously, when using the room feature in some games, everyone was named “Citra”!
+
This issue caused a lot of confusion and made it very hard to identify individual players. The problem was due to a stubbed function in the friend service that was hardcoded to return “Citra”, regardless of the name the user had configured in the Citra settings. vitor-k corrected this and now the user-configured name is displayed correctly.
An arguably simpler way of taking screenshots in game, without taking you away from the action to name and save them! Use the Capture Screenshot hotkey (default hotkey being CTRL+P) to quickly save them to the screenshots folder in the Citra User Directory.
Are you tired of the same old Light and Dark themes? Good news! Citra now offers two new themes: “Midnight Blue” and “Midnight Blue Colorful,” inspired by the yuzu themes of the same names. These themes provide even more customization options for your Citra experience.
When closing Citra SDL, the command line counterpart to our normal GUI version that most people will be used to, the window would remain open unintentionally which required a forceful shutdown to close properly. This would result in cleanup tasks, such as video dumping, failing. This isn’t very nice if you’ve just spent a long time working on a video just to lose it!
+
By implementing a graceful shutdown, the window will close normally and a standard cleanup can be utilized. This results in better closing practices for the SDL version of Citra, and ensures that any data is not lost either!
Another very long awaited feature, Separate Windows, has arrived in Citra!
+
Since the conception of Citra in 2014 (yes, that long ago!) users had been asking for a way to split the two screens of the 3DS shown in Citra into two separate windows. This would allow you to move the two screens around to wherever you want on your PC, and to be used on two separate monitors too! Unfortunately, no one was able to do this for a very long time, until epicboy came along…
+
To enable this feature, head to View -> Screen Layout -> Separate Windows from within Citra. Launch your game, and from there you can edit the size and location of the windows to wherever you want on your PC!
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Map on one screen, gameplay on the other!
+
+
+
+
+
+
Ask for confirmation when changing games from the game list (#6186) by foghawk
+
When you run Citra without Single Window Mode enabled, you have the game window and the game list window open at the same time. If you clicked another game in the game list, it’d instantly boot, closing your current game.
+
After experiencing this themselves when accidentally launching another game while already in a game, foghawk added a confirmation check. No longer will you lose any important save data from this issue, and you can carry on playing after selecting one of the two options!
Based off of the yuzu implementation of the same name, Per-Game Configurations have landed in Citra! This is part of a series of changes coming to Citra to modernize the frontend of the emulator.
+
With this new change in Citra, you no longer have to manually adjust the settings every time you launch a game. Each game now has its own individual settings profile that you can customize to your liking. You can easily modify the emulation speed, graphical settings, audio settings, and volume of each game, among many other options. This feature saves you time and hassle, allowing you to quickly jump into playing your favorite games without worrying about adjusting settings every time.
+
With this PR, the option for Alternate Speed, which was available in the general settings of Citra, has been removed in favour of an option called Per-game Emulation Speed. This setting works in the exact same way as the previous Alternate Speed setting, however it is now found inside of the per-game settings instead of the global settings. The hotkey for this has also been renamed appropriately to reflect the name change of the setting.
+
Individual config files for each per-game setting you may have are stored in config -> custom -> <titleid>.ini These .ini files can be edited using a text editor application, and the changes will appear in Citra.
+
This is another addition which has been highly requested in the Citra community, and we are proud that it is finally here.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ New way to configure your games!
+
+
+
+
+
+
Change Monoscopic Render mode to a dropdown (#6215) by vitor-k
+
Just a small QoL update here! Having a dropdown box to change between two settings is pretty clean, don’t you think?
+
Stereoscopic is the default in Citra for 3D capabilities, which displays the 3D to both eyes at the same time. Monoscopic rendering emulates the 3D capabilities of the 3DS to one screen for each eye. The Stereoscopic 3D modes will use various methods for displaying each screen to the correct eye, but monoscopic mode just chooses one of them to be displayed. Some games render differently depending on which eye is shown. The major image differences between the eyes happens at 0% depth, as some games do not bother rendering some elements of in game material to both eyes.
+
jakedowns implemented a left eye option for the Monoscopic Renderer to further Citra’s compatibility with ReShade, a post-processing injector for video games. However, the initial tick box included with the PR to switch from the left eye to right eye was just a little clunky.
+
By adding a dropdown box to change between the left eye and right eye, this ensures that the games will display correctly on Citra while emulating the 3DS’s 3D capabilities.
Fix framebuffer size on fractional scaling display (#5435) originally by kevinxucs
+
Prior to this PR, users using fractional scaling would encounter a bug that made the emulated image not render correctly.
+Fixing the framebuffer size ensures that the image is displayed correctly on your screen when using the GUI for Citra.
+
Add a “Mute Audio” hotkey (#5463) originally by Kewlan
+
This is what it says on the tin! A keyboard hotkey to easily mute your game audio without having to mess about accessing settings. This allows for more seamless gameplay, especially for those who use controllers and just have their keyboard off to the side for hotkey usage.
+
Fix various spelling errors (#5670) originally by Morph1984
+
Even when working on a giant project like Citra with many developers, spelling mistakes still sometimes slip through the cracks. We’re only human!
+This PR cleans up any spelling mistakes found in Citra to make sure it is clear and understandable to users.
+
Update submodule discord-rpc to latest (#5810) originally by CaptV0rt3x
+
As you may be aware, Citra utilizes Discord RPC to display the current game you are playing onto your Discord profile.
+This PR updates the discord-rpc submodule to the latest version, as well as a few minor bug fixes, to ensure that you are still able to show your favorite game(s) to all of your friends!
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Show off your game to all your friends!
+
+
+
+
+
+
Fixes to compatibility list translations (#6123) originally by Docteh
+
Translations for the compatibility ratings and sorting categories for ROMs had been completed for many languages, but never officially implemented in Citra! This PR just fixes this little oversight and now Citra serves these ratings in many languages from across the world.
+
Surprise Announcement
+
Last but not least, we are happy to announce that one of our most requested features is now in development!
+
Developer GPUCode has been hard at work adding a brand-new Vulkan backend to Citra! Vulkan is a graphics API similar to OpenGL which is currently used for Citra’s video backend. Unlike OpenGL, however, Vulkan allows for a much lower-level access to the GPU, allowing us to make use of optimizations that are currently not possible in OpenGL.
+
Please note that this feature is still very much a Work-In-Progress, but initial tests have been very promising already! With some configurations, performance in games has more than doubled, with Android devices receiving a significant speedup, especially for those using a Mali GPU.
+Mali GPUs, which are commonly included with Exynos and MediaTek SoCs, are known for having poor OpenGL ES drivers. This causes devices with those GPUs to have low performance on Citra while using our OpenGL ES backend. With the addition of Vulkan, Citra is made more accessible to many more people, not just those who have a Snapdragon SoC.
+
To achieve this feat, GPUCode has been undertaking a massive rewrite of the OpenGL backend and the video_core as well, to streamline and simplify the code, making it easier to reuse code between both backends.
+
Another advantage of Vulkan is being able to use MoltenVK on MacOS devices. We have recently changed our OpenGL requirements from 3.3 to 4.3 (more on this is explained in our FAQ) in an effort to modernize Citra’s graphical backends. Since Apple has dropped support for modern OpenGL back in 2018, this has resulted in our users on MacOS being stuck on an older version of Citra, not being able to use all the shiny new features we’ve covered here!
+Using Vulkan, support of Citra will be brought back to thousands of users on their Mac devices!
+
We are very excited to share more information about Vulkan at a later point, as it is still being worked on every day. Please be patient while this massive effort comes to life, as a big project like this does take a long time to materialize!
All in all, it has been a tremendous couple of years for Citra development, albeit a bit slow. We hope this Progress Report goes a long way to show that Citra development is very much alive and active, despite the long period of silence on our website.
+We are proud of our developers, new and old, who have shown us the love they have for this project in many ways. Expect to hear more continued updates from us soon!
+
If you want to support this project, we have a Patreon! Donations to the Patreon go directly to our team to assist with obtaining hardware for testing and keeping our servers up and running. Donations are not required, but are greatly appreciated!
+
If you are looking to contribute to Citra or just want to get involved with our community, you can find us on our Discord server or on our IRC channel (#citra @ Libera.Chat).
+Additionally, we’re still looking for writers! If you are interested in being a writer of these blog posts, please reach out to us on Discord.
+
Thank you for reading and keep your eyes peeled here, there is more to come in the future!
Doesn’t it feel like it was just yesterday when Citra released its first progress report in years? It certainly was exciting, finally reaching a point of having tangible progress and being able to share it with everyone!
+As we said in the previous progress report, Citra is alive and well, and as a result, we have even more Citra improvements to talk about. So, dear reader, it’s time for another progress report which is sure to excite you!
The hallmark of the 3DS, and any Nintendo console in fact, is the HOME Menu.
+With each console generation carrying a unique aesthetic, it’s no surprise that so many people hold it near and dear to their hearts. The soothing music, pleasing visuals, and the nostalgia alone are plenty of reasons to want to emulate it alongside the actual games. It’s also very important for the preservation of the 3DS, something that the recent closure of the Nintendo eShop for the 3DS and Wii U has made abundantly clear.
+
However, there was a small problem in fulfilling this dream: it didn’t actually work in Citra…
+
To cut a long story short, there were a lot of problems that needed to be overcome. The HOME menu in Citra had always been plagued with problems. You couldn’t launch system applets or regular titles from it, the themes didn’t work, the setup would often softlock (preventing users from completing it), and a bunch more issues meant that the HOME menu was far from usable.
+Something had to change, and fast. Citra needed to expand and find that special developer with the ability to undertake such a massive effort.
+
Enter Steveice10, the author of FBI, legendary title manager for the 3DS. A staple homebrew app of a modded 3DS. With their extensive knowledge of the 3DS operating system and all of its inner workings, they joined the Citra team in order to tackle this issue once and for all.
+
Add option to configure to download system files from Nintendo Update Service (#6269, #6356) by Steveice10 and B3n30
+
With the goal of making the HOME menu fully accessible in mind, Steveice10’s work began. However, before any accuracy improvements could be made, there was the matter of the accessibility of the HOME Menu. Dumping the 3DS System NAND for use in Citra was, relatively speaking, a cumbersome process.
+
Building off of the past work of another Citra developer, B3N30, these PRs add the ability to download the 3DS system files from Nintendo servers directly from Citra’s GUI! This requires you to dump the necessary keys from your console, the process for which is detailed in our AES Keys guide.
+
There are 3 options you can choose from when downloading system files from the Nintendo Update Service (NUS) through Citra: Minimal, Old 3DS and New 3DS.
+Minimal downloads only the main files that can help with running games on Citra, such as the System Archives, while Old 3DS and New 3DS fetch the full firmware used by their respective systems, which includes the HOME Menu.
+
Alongside these download options, there is also a setting to select what region’s firmware you want to download. No longer will you need to import a Japanese 3DS to use the Japanese HOME Menu, just download it straight to your PC through Citra!
+Do note that you still can dump all of the necessary data to use the HOME menu in Citra straight from your 3DS using threeSD, this is just an easier way of doing so!
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ A simple way to download all the system files you need for Citra.
+
+
+
+
+
+
Implement PrepareToStartApplication, StartApplication, and WakeupApplication (#6280) by Steveice10 and Subv
+
With the accessibility issue resolved, Steveice10 could now begin working on making the HOME menu more usable in Citra.
+Continuing on the trend of reviving abandoned projects from the past, this PR implements some important APT service calls used by the HOME Menu in order to start applications. Originally the work of Subv, it addresses one of the longest standing issues with HOME Menu emulation, which was that attempting to launch anything from it would result in an instant crash.
+
The implementation had been left untouched and neglected for years, until Steveice10 cleaned up the code and finally got it merged into Citra.
+
The benefits aren’t limited to just the HOME Menu, however. While these functions are mainly used by the HOME Menu, this doesn’t mean that games can’t take advantage of them either. A notable example is Teenage Mutant Ninja Turtles: Master Splinter’s Training Pack, which attempts to shut itself down in order to launch its games, causing an unexpected crash. Now it’s fully playable!
NIM stands for Network Installation Manager, and is a 3DS system module that handles title installations from the CDN. This in turn creates a bunch of services, of which nim:u is the so-called “updater service”. This is used, for example, for the system updates in the 3DS system settings.
+Without this service properly implemented, Citra would exhibit strange glitches, such as instability around app icons on the HOME Menu, or random downloading of present icons with garbled titles.
+
Citra did, in fact, have a portion of this module semi-implemented in the past, but it wasn’t exactly put to good use. Back in 2017, Citra developer Subv added the CheckForSysUpdateEvent syscall, which allowed the HOME Menu to boot.
+However, doing anything other than just looking at the pretty background would softlock the emulator. One of the caveats of this addition was that the LLE NIM applet, used for handling title installations as mentioned above, needed to be enabled from the debugging menu, which wasn’t very user-friendly or obvious.
+
To address this issue, Steveice10 implemented stubs for the nim:u service based on their own reverse engineering work of the 3DS.
+All the information they uncovered has been added to 3dbrew to contribute to the ongoing effort to better understand the 3DS’s operating system. Feel free to take a look if you’re interested in the dark arts of HLE emulator development!
+
The result of all of this? All of the aforementioned issues have disappeared and it is now possible to launch apps without enabling LLE NIM, as the HLE stubs are accurate enough to satisfy the HOME Menu!
Return installed titles in GetNumTickets and GetTicketList stubs. (#6292) by Steveice10
+
When games are installed to the 3DS, they come with a ticket that provides the console with the rights and encryption keys to launch it. Citra doesn’t care about these tickets, so it usually discards them when installing a CIA file. However, the HOME Menu uses two commands, GetNumTickets and GetTicketList, to determine what titles are installed on the system when populating the application grid. Since we have no tickets, none of your installed titles would appear on the HOME Menu.
+What’s the point of being able to access the HOME Menu if I can’t launch my games?
+
Instead of returning an empty list of tickets, we can pretend that any installed CIA has a ticket. That way the HOME Menu will discover and display games correctly.
+
+
+
+
+
+
+
+ It's just like unwrapping a gift on Christmas!
+
+
+
+
+
+
Currently, only .cia (CTR Importable Archive) installed titles are detected by the HOME Menu. If you would like to try this out in Citra yourself, make sure your games are dumped as .cia files and installed into Citra via File > Install CIA…. Other files, such as .3ds and .cxi, still need to be launched from the Citra game list as normal.
+
Implement additional applet state management (#6303) by Steveice10
+
Upon booting a 3DS for the first time, you will be met with a handy setup guide before being able to access anything else on the system. Needless to say, it’s also the first thing you will encounter when booting the HOME Menu in Citra.
+Unfortunately, it has also been riddled with issues ever since the beginning of the emulator’s life. Attempting to load the most important and well-known feature of the 3DS setup guide, the Nintendo 3DS User Agreement, would cause the emulator to freeze, thus preventing anyone from actually completing it!
+
+
+
+
+
+
+
+ Well... that isn't supposed to happen.
+
+
+
+
+
+
It wasn’t until recently that the cause of this freeze was really understood. As it turns out, the settings app preloads the software keyboard applet for later use. When the Nintendo 3DS User Agreement is launched, it is supposed to close this preloaded applet, so that it can load the EULA applet instead.
+However, due to a combination of missing logic to provide applets with the correct ‘slot’ (Application, Library Applet, System Applet, or HOME Menu), and the command to close an applet not being implemented, the settings app was unaware that the keyboard applet remained loaded.
+
By implementing the additional state management required for applets, the accuracy of Citra’s applet manager has been improved tremendously, bringing it closer to the real APT behavior of the 3DS.
+This means that the old workarounds required to get the HOME Menu to boot are no longer required! Not only that, but launching system applets now also works perfectly.
+
+
+
+
+
+
+
+ Now you have another EULA you can skip-I mean, thoroughly read!
+
+
+
+
+
+
Add Config block enums documented by 3dbrew (#6206) by SachinVin
+
Even if one managed to bypass the broken EULA, completing the HOME menu setup still wasn’t possible! Upon reaching the Parental Controls setup screen, the emulator would warn the user of a fatal error, with the only options being either continuing, which would freeze Citra, or aborting entirely. This was the last piece of the puzzle to make the setup screen fully usable and it had to be resolved.
+
Following the advice given by the popup and looking at the generated log files, developer SachinVin spotted some configuration blocks Citra was missing and were being accessed by the setup screen. Adding those missing configs fixed opening the Settings applet and, combined with the improved applet state management, allowed the system setup to be completed.
+
Implement app management support (suspend, resume, close, etc) (#6322) by Steveice10
+
So far, we’ve discussed using the HOME Menu, launching games and applets from it, and completing the system setup process. However, it feels as though we’re forgetting about something…
+
Oh! Doesn’t the 3DS let you exit out of apps and back into the HOME Menu, what about that? Well, fear not, we’ve got you all covered.
+By implementing support for most application management commands and home button notifications, operations such as suspending, resuming, and closing applications from the HOME Menu are now supported in Citra!
+
In addition, the GSP module is now able to capture the screen framebuffers, which correctly emulates the effect when suspending applications. All in all, with these changes you can easily boot the HOME menu and use it to launch system applets and games, suspend or close them, and then launch another game or applet!
+
+
+
+
+
+
Exploring the File menu will also yield a pleasant surprise: there’s now a dedicated “Boot Home Menu” option in the GUI for Citra. This will both automatically detect the correct HOME Menu application, and adjust your region setting based on the firmware region that you’re attempting to launch. In the past, the HOME Menu was entirely hidden from the game list, forcing potential users to go on a wild goose chase inside the NAND folder in an attempt to find the correct application file for their corresponding region.
+You can now say goodbye to wasting time trying to find the correct app name, as Citra will take care of that for you!
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Hey, there’s even a way to launch the region you want!
+
+
+
+
+
+
But this doesn’t mean that our work is done, far from it. Steveice10 has added a very early approximation of DSP sleep, so that apps will not hang while trying to sleep the DSP when suspending titles. However, some games, such as Pokémon X, may still get stuck on this or exhibit annoying audio artifacts in the process.
+Additionally, some titles (e.g. Super Mario 3D Land) can crash if you try to close them from the HOME menu. This is because some services, required for cleaning up kernel resources, are unimplemented currently. Most built-in titles, such as Mii Maker or Nintendo 3DS Sound, should work fine, however. Our experimental Canary builds contain some fixes for these aforementioned issues. These fixes still need more testing before being merged into Nightly though, so we encourage you to give it a try and report any bugs you come across!
After the aformentioned APT improvements had been merged, we started receiving reports of certain games, such as Bravely Second: End Layer, crashing. This game, as well as others, crashed when the Mii selection dialog was activated. In the absence of system files, Citra will use an open source replacement for Miis. But, after setting up the HOME menu, there’s no need to use the replacement and the native 3DS selection will be shown instead. Any Miis you create through Mii Maker will be available in the games you play! However, none of that would be relevant, if the native selection always crashed, right? So, Steveice10 investigated the issue and discovered that the now more accurate applet handling had exposed further inaccuracies. More specifically, problems arose when CancelLibraryApplet was called on an applet that hadn’t started yet, as it would fail to receive the cancellation message and de-register itself.
+
“What’s the fix?” you might ask. Firstly, Steveice ensured that the applet update event starts immediately on creation. Then he implemented a distinction between running and active applets to determine what the update event should do each cycle. This fixed the crashing issues, not only in Bravely Second, but in Super Mario 3D Land as well. Enjoy selecting your Miis!
The ns:c service was introduced with firmware version 5.0.0-11, and appears to be used only by the Instruction Manual applet for triggering SD/Game Card removal errors when ejecting the media that the manual is stored on.
+By implementing a stub for the aforementioned service, the instruction manual now works on Citra!
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Very important for the preservation of the 3DS.
+
+
+
+
+
+
Skip address range checks for privileged memory (un)map (#6407) by Steveice10
+
Another corner of the HOME Menu that never quite worked was the Internet Browser applet, which would mysteriously cause the execution to break, alongside a healthy dose of memory errors.
+
[ 19.448994] Debug.Emulated <Critical> core/hle/kernel/svc.cpp:Break:1120: Emulated program broke execution!
+[ 19.448994] Debug.Emulated <Critical> core/hle/kernel/svc.cpp:Break:1136: Break reason: PANIC
+[ 19.449124] HW.Memory <Error> core/memory.cpp:Read:469: unmapped Read32 @ 0x000000FC at PC 0x00278C18
+[ 19.449277] HW.Memory <Error> core/memory.cpp:Read:469: unmapped Read32 @ 0x000000A0 at PC 0x0028117C
+[ 19.449282] HW.Memory <Error> core/memory.cpp:Read:469: unmapped Read32 @ 0x000000C8 at PC 0x0028117C
+
These errors occured because Citra’s code for loading CROs (relocatable code, similar to DLLs on Windows) did not allow parts of the internet browser’s code to be mapped into memory.
+By inspecting the kernel through disassembly, Steveice10 determined that the address range checks that Citra used for maps/unmaps were not actually used when mapping privileged executable memory, such as in this case. Thus, skipping these checks for the privileged case allowed the Internet Browser applet to load properly.
+
Do note that this is not fully functional in Citra at the moment. You will not be able to browse the web from inside Citra using the Internet Browser.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ I wonder what the bookmarks include…
+
+
+
+
+
+
And there you have it! All the changes we have made in Citra to majorly improve the functionality of the HOME Menu. Of course, not everything is perfect just yet, but we are working hard to ensure that this vital part of the 3DS experience is preserved through Citra. There will be more updates in the future on this, keep an eye out if you’re interested.
Storage Access Framework, which is often abbreviated to SAF, is Google’s method of implementing scoped storage. On its own, the idea has merit; with scoped storage, apps can’t see all of your files or access any data from other apps, meaning you don’t have to worry about any of your personal data being stolen by bad actors.
+This implementation of that idea though, is absolute garbage. When using SAF, apps cannot access files outside of their data directory without using so-called “content URIs” for addressing them.
+Citra, however, being a native C++ program, assumes that files can be addressed with paths that are delimited by slashes and can be stored as strings. Updating the entire codebase to use these URIs would be a massive undertaking for little benefit.
+
Did we mention the performance of it yet? No? Well, SAF is so slow that we observed abysmal shader stutter, not from the OpenGL driver but from the disk shader cache opening files to save the generated program code. Opening the file suddenly became slower than actually compiling the shaders!
+
Be that as it may, there are several options to choose from when deciding on how to support SAF, each of which have their own pros and cons. For example, the simplest is having the emulator folder inside the app data directory. This is very nice and clean, as direct paths can easily be used with no real change to the emulator code. It’s also very fast since it bypasses the need to go through SAF when accessing the folder.
+On the other hand though, that directory is considered “fragile” on devices running Android 9 and below, meaning that uninstalling Citra would completely erase all the data: games, saves, updates, shader caches etc. And while Android 10 introduced a new option to prevent this from happening, Citra still supports Android 9 devices, so we can’t rely on it.
+
Another heavily requested feature has been storing the game and user folders on external storage. This used to be possible on Android 10 and below, when SAF wasn’t enforced upon everyone. Nowadays though, accessing any form of external media is prohibited without SAF, meaning the above option won’t cut it.
+Migrating the user folder is also of concern to us, especially when a lot of users are still stuck on the currently outdated Play Store build of Citra, as opposed to an .apk file from our Nightly repository. By default, the user folder used to be located in /sdcard/citra-emu, thus moving it to the app directory requires some form of migration scheme.
+
The second option is more complex, but is the one that was implemented due to the reasons mentioned above.
+To make it feasible for the user to select a directory using SAF, every path must be adjusted to account for this new content URI scheme. This entails inventing a way to squeeze a content URI into a string in a way that can be reversed once it’s time to open the file. The PR for the feature, implemented by hank121314, was originally opened on the now defunct citra-android repo, where it stayed in review hell for over a year.
+Recently though, with tension at an all time high due to Google’s enforcement of SAF for all apps on the Play Store, we got this to a point where it could be merged and the issue was swiftly resolved.
+
So how did they do it? Simple. Citra “pretends” that the user directory is called /, and then whenever some C++ code opens a file using a path that starts with /, it gets turned into a URI in the user directory.
+What’s clever about the / scheme is that, to the C++ code, it really looks just like a regular path. All operations that inspect paths and add or remove parts of paths will simply work. The downside, however, is obvious: anything outside of the user directory is not accessible this way and needs special care in the frontend code.
+
Another benefit of this approach is that it’s quite simple to migrate from an old Citra build, as the user folder does not need to be moved. You simply need to grant the app permission to use the old location. We’ve written a small step-by-step guide for this procedure so if you are having trouble, take a look!
+
Update AndroidManifest for Android TV (#6330) by DRayX
+
As Android is an ever evolving operating system, there are many technologies that utilize it. One of these are TVs! By using the Android TV Leanback Launcher, first time contributor DRayX brings Citra to the big screen. Leanback is what is used on Android TVs to display and use mobile apps via either the Google Play Store or an installed .apk file.
+
Android TV support for Citra was planned in the past, but due to a lack of testers and developers, it had to unfortunately be scrapped. Thankfully, with time and effort, we are able to provide support for launching Citra on an Android TV as we initially hoped!
As mentioned in the previous progress report, we are looking to modernize Citra in many ways and get it up to speed with other emulators. This also includes modernization of the Android app!
+To give the app’s theming a breath of fresh air, t895, developer for the Android apps of the emulators Dolphin and yuzu, has stepped up to this task.
+
Starting off with how the app responds to touch navigation, t895 ported over a PR from Dolphin which aimed to upgrade the UI animations to something a bit more modern, and also helps with how fast you can get around the app! This change, although it looks small, greatly improves the user experience of Citra.
+
Next up on the list of changes is starting the migration of the UI to the Material 3 system, introduced in Android 12. Material 3 is the latest design system from Google, giving developers the tools and inspiration needed to create a beautiful looking app.
+As humans, we are all about aesthetically pleasing design, and this migration proves just that for the Citra app. This change includes upgrades to the layout of the app, the themes, icons, colors, and so many more changes just to make it squeaky clean!
+
Next, we’re turning our focus towards the app icon for Citra. Beginning with Android 13, but being supported by devices running API level 26 (Android 8) or newer, apps have the option to enable the use of themed icons on the home screen. This means that the app icon will match the theme of the phone the best it can, to match the general aesthetic of the phone. For example, with themed icons, Citra will be able to tell if your phone is in light mode or dark mode, and change its icon design accordingly. A neat little change, but one that will help Citra blend in nicely with the rest of the phone if you choose so.
+
Not long to go now… splash screens! Introduced in Android 12, but being supported by devices running API level 23 (Android 6) or newer, splash screens bring a nifty little Citra logo that pops up when you open the app to let you know it is launching correctly and to smoothly transition you from the rest of the phone into Citra to fully immerse yourself in the joy that is 3DS emulation!
+
And finally, edge-to-edge display. No longer do you need to worry about that pesky navigation bar at the bottom of your phone getting in the way. Citra now renders right to the edge of your screen, giving you a full display of your favorite games.
+
All of these changes add up into one big overhaul of our UI, bringing the freshest look right to your device! We have more planned for our UI on Android in the future, so keep an eye out here and we’ll update you when we can!
Avoid reopening files every time a shader needs to be written. (#6344) by SachinVin
+
Shader stutter is pretty annoying, no matter how you put it. Citra has always had issues with it, mainly because we are at the mercy of the OpenGL driver. Most drivers do end up taking their sweet time when compiling shaders, however after merging the new SAF implementation, it became much-much worse than before, with individual stutters reaching a mind-boggling 5 seconds even on powerful hardware.
+So what gives?
+
As it turns out, our disk shader cache opens the cache file every time a new shader is generated in order to serialize it. That’s fine and dandy over on Citra Desktop, where ignoring the characteristics of the storage medium, file access is relatively fast. It also reduces the chance of shader cache corruption when Citra crashes or is terminated abnormally, which is really important for any emulator. But with SAF added to the mix, the overhead of that method just became too much to bear.
+
In the end, the solution came from developer SachinVin, who rewrote the disk cache to only open the file once at the beginning of the emulation session.
SAF strikes again! The slowness of file operations negatively impacted the user experience by making the game list incredibly slow to load. For users who only have a small handful of games in their game list, this wasn’t particularly noticeable. However, for anyone with a large enough game library, the loading speed became unbearable.
+
The only way to alleviate this issue is to limit file access as much as possible, and that’s what was done with this PR. Utilizing their android expertise from their work over at Dolphin, JosJuice managed to speed up the process by centralizing game information queries to a single class, instead of having separate file access calls for fetching the TitleID, title name, game icon, etc. This ended up saving a bunch of time that was wasted on opening the same file multiple times.
+
Open cheats by long pressing game in game list (#6491) by JosJuice
+
Normally to edit a cheat for a game, you’d have to edit it whilst the game was running. This was fine if the cheat codes were working, but what if they were causing the game to crash? You’d have no way of disabling them unless you crawled through the hell that is the Android file manager.
+
A simple fix to this, based off of a similar addition to Citra Desktop that we’ll get to later, involves enabling cheat code editing by long pressing the game in the main menu of Citra. This allows users to modify cheat codes directly from Citra, regardless of whether a game is running or not. The previous method of adding cheat codes in Citra still remains.
+
Offload CIA installation to background thread (#6508) by SachinVin
+
With the addition of SAF, some things in Citra Android slowed down a lot, to no fault of our own. That’s just how SAF works, sadly.
+One of these is the installation of CIA (CTR Importable Archive) files. These are mainly used to install games, update files, and DLC files. With the installation of these being so much slower than previous Citra builds without SAF, Android believes that the app has frozen and forces it to crash due to the installation running on the UI thread.
+
By offloading CIA installations to the background thread instead, we now prevent Android from accidentally terminating Citra prematurely. But, how are you, as a user, meant to know if your installation is actually working?
+
This is where the new notification progress bar comes into play. This convenient progress bar notification allows you to monitor your CIA installation, even when Citra is minimized! It also will notify you if the installation has been successful or if it has failed, which is handy to know.
+
+
+
+
+
+
+
+
+
+
+ Installing updates and DLC has never been easier!
+
Citra supports many operating systems, and macOS is no exception.
+This addition addresses an issue related to the camera function on this particular OS, where previously, if emulation was paused and then resumed, the camera would fail to resume as well.
+
The problem stemmed from the repeated invocation of CheckAuthorization, a function that checks camera permissions with macOS each time StartCapture is called. This approach was far from ideal, so this change optimizes the process by calling CheckAuthorization only once, before the media capture starts.
+This ensures that the camera will resume again after the emulation is paused, resulting in features such as QR code scanning to work as intended.
+
Fix global settings being inaccessible on macOS (#6235) by Steveice10
+
As we mentioned earlier on, we recently added per-game settings to Citra! However, in the beginning, they also broke the global settings! This was a big deal, as the main way to configure your Citra instance was now lost.
+Fortunately, the fix was relatively simple; manually specifying the roles for the key menu actions, such as About and Preferences, instead of relying on the default Qt heuristics. With this, the global settings are once again accessible!
Somewhat recently, Apple released a new processor for their devices utilizing the ARM architecture, named Apple silicon (M1/M2). Citra’s x86_64 macOS builds technically worked with these new devices through Rosetta 2, in the sense that your game would launch, but it would also result in game bugs; freezing and crashing pretty frequently.
+Building it natively for ARM was often a solution, a solution inaccessible to the average user, unfortunately. An official Citra build was needed for users running those Apple silicon devices.
+
However, as you may be aware, Apple does not support OpenGL 4.3, which presented us with a big issue. Apple officially only supports Metal, their own proprietary graphics API, adding support for which would require a lot of work. So, how are we going to get Apple silicon devices to run on Citra when macOS isn’t even a supported platform?
+Banking off of the fact that we have a new Vulkan graphics backend quickly making its way into Citra (have we mentioned that yet?), we can utilize MoltenVK, a mature translation layer that converts Vulkan API calls to appropriate Metal ones. With this solution in mind, Steveice10 got to work implementing a universal macOS build for Citra that covers both x86_64 and arm64.
+
Initially, Citra was set up to build a universal app for both architectures all at once. However, due to a new library introduced with Vulkan not supporting multi-arch building correctly, we had to change approaches. Instead, we now build for x86_64 and ARM separately and combine the app at the end, giving us the same result without having to worry about adapting build scripts for multi-arch.
+
The PR is currently not usable in the latest Nightly, as it is dependent on Vulkan being merged into Citra. It is, however, available to use in Canary. If you have an Apple silicon device and want to use Citra, please switch to the latest experimental Canary release, downloadable through our installer.
Whilst working on adding the Vulkan backend to Citra, we came across build failures when trying to build for macOS. The problem? Any macOS version under macOS 11 did not support everything we were trying to accomplish with adding Vulkan to macOS through MoltenVK. Many devices from this time period, 2009 through to 2012, don’t even support Metal!
+By upgrading our macOS target to 11 (Big Sur), we can ensure that all features used by the Vulkan backend are available and work properly.
+
Graphics
+
Prepare frontend for multiple graphics APIs (#6347) by GPUCode
+
For being the first PR in our attempt to move away from OpenGL, this one is quite mundane on the surface compared to the other ones. However, it lays the foundations to allow Citra to support multiple rendering backends by abstracting key rendering functionality into common classes.
+
A neat result of that effort is that the Software renderer no longer depends on OpenGL hardware acceleration for presentation. This means Citra can technically run on systems without a GPU using the Software renderer. Additionally, the Software renderer has been turned into a Graphics API, so it’s much more obvious when it’s being used. Before, in order to enable Software rendering, one had to disable the Hardware Renderer option, which wasn’t really made obvious to the user. Now, we’ve added a handy little drop down to choose which Graphics API you’d like to use!
Looking at the name of the PR, it’s not immediately obvious what this PR aims to achieve. What it does is rework several important aspects of GPU emulation that had remained untouched for years.
+One of these is that it greatly simplifies texture uploading and downloading, the methods for which had quickly grown to be complex and hard to understand over the years. This was most notably seen when using custom textures combined with texture filters, where the code would just fail, resulting in some pretty messed up looking textures. But more on that later. To summarize, this code is now much simpler and more optimized!
+
Another pain point of the old cache was mipmap handling. A mipmap is a sequence of textures, each of which is a progressively lower resolution representation of the same image. Many 3DS games use mipmaps in order to make graphics look cleaner at a distance.
+Citra’s problem was that the old cache considered them as separate textures, requiring an expensive tree-like structure to maintain and properly sync them. In addition to this, every surface allocated an excessive amount of mipmaps which increased memory usage, especially when texture filtering was used.
+
By having surfaces own the entire mipmap range, the cache can directly upload and use mipmaps without needing to sync them. This reduces the amount of surfaces cached and, in turn, the lookup overhead. So these changes not only make mipmaps faster, they also fixed a few games that didn’t work correctly before, most notably the homebrew port of the game Portal, which displayed nothing but a blue void when using the hardware renderer.
+
All of these changes are indeed quite nice, but what’s especially interesting are the OpenGL specific optimizations.
+After a bit of profiling, GPUCode found that the backend was handling certain operations inefficiently, which really hurt performance on less-than-stellar drivers, such as Android phones utilizing a Mali GPU. By taking the time to correct some of these, the performance of these GPUs have been significantly increased by at least 40%! Even better, the annoying graphical flickering that could be observed on some lower-end Mali devices has now disappeared as well.
Question time! Have you heard of something called texture tiling? If you are a graphics developer, you probably have. The rest of us, not so much. As a concept, it’s actually pretty simple: you take an image and chop it into smaller NxN squares of pixels. Such an arrangement can be beneficial for graphics hardware for multiple reasons, so it’s no surprise that the 3DS also makes use of this feature to speed up texture processing. More specifically, we should mention that the tile size is 8x8.
+
With this information, it wouldn’t be wrong to assume that texture dimensions must be a multiple of 8, otherwise dividing it into tiles wouldn’t really make sense. And in general this assumption holds true, the vast majority of games respect this limitation in their textures. Until they don’t…
+
Now we get to the fun part: what happens if the texture is smaller than a tile? Being confronted with that question, Citra developer wwylele came to the conclusion, after some tests, that such a configuration was not supported by the PICA GPU the 3DS uses. Due to this, the original code that handled these textures was promptly removed when support for mipmaps was implemented. Said removal caused unexpected issues however, when health bars of all things suddenly went missing in some games. Imagine the horror Citra users came across when in those games the HP bar just did not display correctly! How were you meant to tell if you needed to heal or retreat?
+
This issue was again brought to our attention when first time contributor, Polar-Star, opened a pull request reimplementing the code that was removed. With this change, HP bars are fixed and because this bug negatively affected core gameplay of certain games, we opted to accept this change. We are still investigating this issue to figure out the proper hardware behavior in this case, though we suspect it’s not too far off from this.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Left: Broken, Right: Fixed
+
+
+
+
+
+
Fix distance vector used when calculating lighting distance attenuation. (#6366) by Steveice10
+
Citra is often referred to as the “Pokémon emulator”, and you wouldn’t be too wrong to assume that. Pokémon games have, by far, been the most popular for the 3DS platform, and this translates over to Citra as well.
+So naturally, when something breaks in the game, it tends to get overreported. This is one of those issues that has plagued Pokémon X/Y for a while, so one would assume the solution is quite sophisticated. Right?
+
This issue, strangely enough, just made all the backgrounds in some key cutscenes completely black! The GitHub issue for this glitch was first opened in 2018, but at the time it wasn’t really known what was causing it. What’s more, the black backgrounds persisted even when using the Software renderer, which is Citra’s most accurate (and slowest) rendering option.
+Given this information, it was most likely a fundamental accuracy issue, which deterred a lot of people from looking into it due to the difficulty of fixing such a thing.
+
Fast forward a year and hamish-milne, the mastermind behind one of the most popular features on Citra, save states, attempted to find the cause of this glitch that had eluded many. After poking around for a while, they determined the problem laid in the fragment lighting emulation code.
+For those who aren’t aware, PICA, the 3DS’s GPU, does not support programmable pixel shaders like more modern systems. This means that Citra must generate a host fragment shader to emulate the fixed function pipeline the GPU exposes. What they ended up discovering is that changing how LUT indices are generated for the distance attenuation feature fixed the background lighting. The issue was finally solved!
+
Unfortunately, this wasn’t the end. After performing some tests, Citra developer wwylele determined that the solution was not accurate to the hardware and could potentially break games. Due to this, the proposed solution could not be accepted into the codebase.
And after that, the issue was yet again abandoned throughout Citra’s developer drought. Until recently.
+Steveice10 picked up the issue and after writing a couple of basic hardware tests, came to the conclusion that the bug was different from what everyone had believed. It turns out that Citra always used the view vector when distance attenuation was enabled, something that doesn’t really make sense for directional light, which is usually a directional vector rather than a concrete position. By correcting the code to use the correct length, it not only fixed the background issue, but improved the lighting accuracy in general!
We’ve all been there: controller is properly connected and ready at hand (or keyboard if you prefer, we don’t judge), your favorite game is dumped, set up and ready to be experienced on a shiny new computer, devoid of the limitations imposed by the original hardware. You launch it and… it looks so pixelated and blurry.
+What gives?
+
Fortunately, emulators have your back and provide many options that increase fidelity. Resolution scaling, anti-aliasing, and texture filtering can enhance the experience greatly. Having these options is especially important in Citra due to how the 3DS screens are known for their low resolution, compared to modern HD screens.
+
Often, though, cranking up the resolution isn’t enough. Due to VRAM limitations, textures in 3DS games can look blurry and lack detail when viewed outside of the confines of the console itself. The aforementioned texture filtering feature is useful for upscaling these in-game textures, to make them look better, but the results vary between filters and aren’t always perfect.
+As such, Citra allows for custom textures to be used as well, a feature first added back in 2019 from developer khang06. Since then, many custom texture packs have surfaced, made by talented artists. We are grateful to our community that made this all possible!
+
The implementation wasn’t without its faults, though. It only supported the .png file format, which forces a choice between hefty file sizes or long decompression times. The loading stutter could be mitigated by using the preload textures option, but that requires a ton of RAM and would often freeze Citra without any indication of progress. Another limitation of the previous system was that mipmaps were unsupported.
+This actually made sense from a developer standpoint at the time, since it avoided graphical glitches from missing mipmaps that manifest as black textures at a distance, and made texture replacement an easier process overall. However this hidden abstraction made the code more complex and prevented pack creators from providing their own mipmaps in cases where such a thing was desirable.
+
Most important, however, was the notorious texture filter incompatibility with custom textures, one of the most well known Citra bugs ever! Being first uncovered by a rasterizer cache change made by developer BreadFish64, the bug would result in messed up textures over time, making the game slowly unplayable.
+One might say, “That’s easy then! Why not just revert the PR that caused it?”
+
Well, the change in question is actually quite desirable: it removes fully invalid textures from the cache, in order to speed up lookups and performance. It was briefly mentioned in our previous progress report, go read it if you haven’t already!
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Did someone turn off the lights?
+
+
+
+
+
+
Another thing to consider is the hashing algorithm being used to identify the textures. Up until this point Citra used the deswizzled and decoded texture data as it was the most convenient option at the time. Said approach presents issues though when other graphics APIs enter the picture, namely Vulkan. As a low-level API, Vulkan accurately reports the host GPUs capabilities, meaning that certain formats Citra expects might not be natively supported, requiring conversions to work. Such conversions break the previously trusted hashing, which could lead to missing textures.
+
With the hopes of fixing the aforementioned issues, GPUCode embarked on a journey of fully rewriting the custom textures implementation. The result is a greatly improved system with a bunch of cool new features, like support for compressed formats such as BC7/BC5/ASTC and their container file formats DDS/KTX. By using these formats, the size of a texture pack can be decreased significantly while also maintaining decent image quality. Note that the BCn formats are unsupported on Android devices. So, if a creator wants to target mobile, we recommend either sticking to png, or having an alternative ASTC version of the pack.
+
Async texture loading is also supported to mitigate loading stutters, which are especially noticeable on Android with the recent SAF implementation we mentioned before. We’ve also added a new hotkey to toggle between normal and HD textures without restarting the game, which is especially useful for demonstration purposes. Oh, and the icing on the cake: texture filtering with custom textures should now work as expected!
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Ahhh, much better.
+
+
+
+
+
+
Alongside this new implementation, a new method of hashing textures has been introduced, which not only guarantees compatibility with any graphics API Citra currently supports or might add in the future, but is also much faster, as it requires less input data than before. Of course, we understand the utmost importance of maintaining compatibility with existing packs, so loading the older hashing format is still fully supported. Although we recommend that new packs be created with the new format so they can benefit from the above improvements.
+
The introduction of the new hash has made it necessary to distinguish between new and old packs. “New” packs are identified by a simple pack.json file, which contains information about it such as name, author, etc., and some configuration options. Using the .json file also allows for hash mappings, giving pack creators the opportunity to assign handy names to textures that don’t strictly follow the dumper naming guidelines. Citra’s texture dumper will write a template pack.json file in the dump directory. Each dumped texture now also includes a handy _mip postfix to indicate whether a texture is a mipmap.
+
And before ending this segment, we have to talk about one more thing… Remember how the goal of custom textures is to enhance the respective beyond the limits of the original console? In the interest of achieving that goal we have added another feature to the custom textures implementation which we are sure pack creators will love: custom normal maps. Normal maps are very widely used in computer graphics to give the illusion of detail without the cost of rendering more polygons. Pretty neat right? You’ve most likely played a game that uses normal maps.
+
+
+
+
+
+
+
+
+
+
+ The power of normal maps is real!
+
+
+
+
+
+
Needless to say, 3DS games also use normal maps to increase detail of certain objects. The low available VRAM however limits their usage considerably. Imagine how much better games could look if they used normal maps for most textures instead of a select few? Well, wonder no longer! Custom normal maps are now a reality! Simply adding the .norm prefix before the file extension is enough to make use of this great new feature.
+By taking advantage of the fixed-function nature of the PICA200, we can easily apply the normal map to any scene that enables fragment lighting, which is the only requirement for it to work. Attempting to use custom normal maps on scenes without lighting will print an error in the log, so watch out for that when trying it out.
+
+
+
+
+
+
+
+
We would like to credit Nerrel for providing us with this awesome demonstration of how normal maps can enhance games like The Legend of Zelda: Majora’s Mask 3D. They have started working on incorporating this feature in their MM3DHD project and we are definitely excited to see the results of this endeavour.
Using preloaded custom textures is usually quite taxing on the system RAM, especially if you don’t have much to begin with. Loading can be very slow and, at times, even freeze your entire PC!
+
By adding a loading screen, you can now track the progression of your preloaded custom textures as your game boots. It also works as an indicator to let your PC know that the app has not frozen, and to not enter it into a “not responding” state. Additionally, this solves the issue of Citra’s inability to be stopped whilst preloading custom textures, which is handy if you need to stop it for any reason whatsoever.
It’s a given that all great movies get a sequel. And because the first refactor was so good, we decided to make a second one! Well, not quite, but we promise this one is worthwhile too. More specifically, it contained the last pieces needed to fully abstract the video core from OpenGL, fixed a handful of regressions from the first one, and even provided some performance improvements.
+
Due to the large amount of changes introduced by the previous PR, it was natural for some regressions to slip through the cracks. As we learned the hard way, messing with many parts of the GPU emulation at the same time can result in strange bugs. For example, players of Digimon World Re:Digitize: Decode reported that some models went missing after the merge, which was caused by an erroneous change to the OpenGL viewport.
Next, let’s talk about Disney. Not the company, but a pretty obscure game they made for the Nintendo 3DS called Disney Art Academy, where you get to draw Mickey Mouse and his friends using the touchscreen and stylus. Given that the core gameplay mechanics require use of the touchscreen and stylus, not many people choose to emulate this title. So we were surprised when a bug report came in, stating that the game had become completely broken after the first refactor.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ This will haunt our dreams…
+
+
+
+
+
+
After some digging, GPUCode found out that the new mipmap implementation was the culprit that robbed Mickey of his face. To go into more detail, texture downloads were not adjusted to account for multi-level surfaces and thus readbacks of these surfaces did not function correctly. Rendering and reading back from multi-level surfaces is quite unusual and not something we often see in games. Regardless, we are happy it was reported to us so that we could promptly fix it!
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Mickey got his face back!
+
+
+
+
+
+
Alright, what about the performance improvement then? Indeed, by changing the data structure used to store surfaces, Citra is now able to cache and search for them more quickly and efficiently. The old interval map was ditched in favour of a simple page table. Memory locality has also been improved by taking inspiration from yuzu’s texture cache. All in all, this change should yield a couple of extra frames in games that perform many cache operations and especially in cases where interval map lookups would slow things down.
What’s better than 5 texture filters? Well, how about 6! Introducing the MMPX texture filter, implemented by first time contributor, stuken.
+MMPX is a texture filter centered around the preservation of those classic pixel art styles we typically see in 8- and 16-bit era video games. Sprites, fonts, you name it, it’s been given a sweet pixel art style with this new texture filter!
+
This new texture filter can be enabled in Emulation -> Configure -> Graphics -> Renderer (Citra -> Preferences on macOS).
OpenAL, or in Citra’s case a variant of OpenAL, OpenAL Soft, is an audio API designed for efficient rendering of multichannel audio.
+
It supports a wide variety of a platforms and can now be used in case Cubeb, our default audio backend, fails for any reason. To get this working in Citra, though, a few things had to be changed first.
+
Before this PR, the input audio settings UI assumed that only the Cubeb backend would be used, and, unlike output, did not have a proper selector for other options. The input UI was edited to allow “Real Device (OpenAL)” to be selected, along with “Real Device (Cubeb)” as before.
+By changing these UI options, along with internal code cleanup to make managing output and input devices more consistent, we can improve Citra’s portability as a whole. We also use OpenAL Soft, as it supports iOS, while Cubeb does not.
+
Implement Apple AudioToolbox AAC decoder (#6510) by Steveice10
+
Apple devices, like Macs and iPhones, use a framework called AudioToolbox to provide interfaces for recording, playback, and stream parsing. This framework can be used to encode and decode different audio formats, such as AAC.
+AAC audio might be something you’re already familiar with in Citra. It was a big reason as to why Pokémon X and Y couldn’t be played properly for many many years. But thankfully, that hasn’t been an issue for a while now!
+
By implementing an AAC decoder backend using the AudioToolbox library, we are able to eliminate the FFmpeg dependency on macOS. And, yes, Pokémon X and Y still work on macOS with this change.
+
Dynamically load fdk-aac and FFmpeg at runtime (#6570) by Steveice10
+
This PR allows Citra to dynamically load the fdk-aac and FFmpeg libraries. These are difficult to distribute due to licensing reasons, but necessary to support features like AAC audio on Linux.
+
This also allows for the Linux AppImages (Yeah, we have those now. More on those later!) to use AAC decoding, so long as the required libraries are already installed on the system. As mentioned just above, Pokémon X and Y rely on AAC audio for the game to have any audio in the first place, and now this works on the AppImages too!
+
However, this change also has an implication for those who use the built-in video dumper. To use the video dumper, you’ll now have to install FFmpeg yourself, from either their official website or via your package manager of choice.
Out with the old and in with the new! Citra has now migrated to Qt6, which brings with it many benefits such as improved HiDPI support, reworked multimedia libraries, as well as better styling support for Windows. Needless to say, quite a few changes were needed to be able to support this new version, with the camera implementation being one of the most challenging parts due to the aforementioned multimedia changes. As a result of this change, it’s important to mention that, alongside other projects like Dolphin, Citra has now dropped support for Windows 7, Windows 8, and 8.1, with Windows 10 becoming the minimum required version. A dwindling user base, combined with security concerns due to lack of regular security updates, have contributed to our decision to make the jump to Qt6, and drop support for these operating systems to focus on their more modern successors.
+
The changes don’t stop there. With the introduction of Qt6, Steveice10 also completely reworked the way Qt dependencies are handled. Instead of needing to manually build and package Qt releases on our ext-windows-bin, Citra’s build system now uses aqtinstaller, which automatically downloads prebuilt binaries directly from Qt’s servers. An added bonus is that we also get more flexibility when it comes to upgrading or adding new Qt libraries!
+
Move CPU speed slider to debug tab and Report Compatibility to help menu (#6250) by FearlessTobi
+
One of the more common issues our Citra support team comes across is users configuring the CPU Clock Speed slider to be either insanely high or low causing their games to freeze. As changing the CPU Clock Speed is very unstable, a warning about this exact issue is given in the UI to deter people from changing it, but that hasn’t stopped some users from messing with this setting anyways, nor some misinformed content creators from recommending their viewers play with it
+
Requested by the Citra support team, this change moves the slider to a less conspicuous area, from the System tab to the Debug tab, to hopefully bring a stop to people accidentally freezing their games all the time. This change also moves the Report Compatibility option to the Help menu, purely because it is more fitting there.
+
Detect and return error if GBA Virtual Console is loaded (#6257) by Steveice10
+
As you may or may not know, an important feature of the 3DS is the Virtual Console. This allows people to play a variety of titles from different consoles throughout Nintendo’s history, such as the NES and Game Boy, right on their 3DS.
+
Sadly, we have a lot of issues with these in Citra. One such issue is that the Game Boy Advance Virtual Console just crashes whenever you’re trying to load a game, because the ExeFS code binary is a GBA ROM.
+This PR adds a simple popup to explain to the user that GBA Virtual Console ROMs are currently unsupported in Citra. Clarity is always key, of course!
Recently added to Citra, the per-game settings bring a new way to configure the settings of Citra on a game-by-game basis. However, not all settings were added with this in one go, as we were unsure which settings most users would find relevant to have here.
+
After hearing your feedback, we decided to add most of the graphical enhancement options to the per-game settings. This includes features such as the resolution upscaling, custom textures, texture filters, and the options for the screen layout. This way, you have many more ways to customize your games to your heart’s content, without having to change the global settings around every time you swap games!
+
On top of this, we also moved the cheats section to the per-game settings instead of being in the global settings. By being available in the per-game settings, cheats can be managed more easily, and are now configurable when a game is not running.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Look, Ma! New settings!
+
+
+
+
+
+
Add consolidated GodMode9 key dumping script (#6396) by Steveice10
+
Something a bit different here… we’ve made our own GodMode9 dumping script!
+
If you’re somehow unaware, GodMode9 is a homebrew full-access file browser for the 3DS, allowing you access to pretty much everything on the console. This app is vital for playing games in Citra, as you must use this to dump your games, updates, DLC, and anything else you may want from your 3DS. GodMode9 can utilize dumping scripts to easily dump a bunch of things at once that the user may want, such as how ThreeSD works.
+
This script is used to dump all the keys needed for Citra into one file, which simplifies things a lot. In the past, you would have to dump many different files such as Boot9, Sector0x96, and NATIVE_FIRM just to get encrypted games running on Citra.
+Now, with the new system file download option through the Nintendo Update Service (NUS) in Citra, which relies on encryption keys in order to be used, it was a good time to find a way to streamline this dumping process once and for all.
+
This new dumping script loosely follows the existing aes_keys.txt format which is supported by Citra, but adds a few new secrets that will be needed for things such as encrypted Amiibo support. This ensures that whatever is needed for use in Citra will be dumped with ease using this script.
+
The download link and instructions for using this dumping script can be found on our AES keys guide. We hope that this will help make your Citra setup experience just that little bit smoother!
An AppImage is a format for distributing portable software on Linux in a compact and simple way. AppImages don’t require any outside installation, and can just be run as is. This makes it very easy to use different programs on Linux, especially to those who are new to the operating system, as using the CLI can be intimidating or just plain time consuming.
+
This was first requested back in 2017, with mixed opinions from both the community and developers. On one hand, people were excited to possibly see an easier way to use Citra on Linux. But on the other hand, the developers were concerned that Citra was not in a state where this could be used back then.
+Nowadays, Citra’s development has come a long way to where an AppImage is a feasible way of shipping Citra to all of our Linux users. As AppImage’s are supported by many different distributions, such as Ubuntu and Fedora, you now have a new way to use Citra on whatever distro you’re on alongside our Flatpak releases.
+
Add warning popup when loading save states for the first time (#6565) by GPUCode
+
Carrying on with the theme of common errors from users… broken save states…
+Pretty much every Citra user has seen this at some point. You save your game using save states, update Citra and… what? My save is now broken? How did this happen?
+
To give a short summary of what happens, save states don’t just save your game, they save the entire state of Citra. Kinda in the name there. When an update is pushed to Citra that changes the state, the previous save states become invalid. This is why it is so important that you do not rely on save states to save your game progression and that you frequently save in-game.
+
Unfortunately, many people do not realize this. Which causes a lot of distress at lost progression and a lot of frustration fiddling around with older builds to get the saves working again. Simple solution? Warn the people of what might happen when using save states. At the very least, this might help people to not lose their progress.
Enable High DPI fixes for Qt >= 5.14 (#6262) originally by Morph1984
+
On higher DPI monitors, any information window, such as the game compatibility reporting tool, would be scaled incorrectly, resulting in massive text size that could not be read due to it getting cut off.
+By utilizing Qt’s new high DPI application attributes for scaling a window, paired with a heuristic to select an integer scale value dependent on the current screen resolution, the scaling issue that has plagued Citra for four and a half years is finally resolved!
Just a few multiplayer additions here for ease when playing multiplayer in Citra with your friends!
+
First off, we have support for hostnames and IPv6 when using Direct Connect! Direct Connect is used to, well, directly connect to someone without having to search through the multiplayer lobby or if they’re hosting unlisted! In the past, the only way to connect to an unlisted room was via an IP address.
+This wasn’t ideal, as it requires knowing the exact IP address in order to connect. With this change, it allows for Citra to use a domain address, as well as IPv6, as an input method to connect to a multiplayer server.
+
And then we have an option to tidy up the multiplayer lobby a bit more, a toggle to hide empty rooms! Sick of shifting through each room manually to see if there is anyone to play with? Fret not, with a simple click of this button, you will be shown rooms that have at least one other person to play with!
+
Both of these additions help make the multiplayer experience in Citra just that little bit better and allow you to enjoy playing with ease, which we all love.
+
Conclusion
+
Well, that’s a wrap! It has been an incredible couple of months for Citra development. We are definitely picking up speed, the likes of which we have not seen here for years, and as promised, the progress reports are continuing.
+A massive thanks goes out to the Citra community, especially the developers. None of these achievements would have been possible without all of the people involved here keeping this emulator afloat. These reports give us the opportunity to showcase the talented people working on this project, so you best believe they’re going to be long!
+
If you want to support this project, we have a Patreon! Donations to the Patreon go directly to our team to assist with obtaining hardware for testing and keeping our servers up and running. Donations are not required, but are greatly appreciated!
+
If you are looking to contribute to Citra or just want to get involved with our community, you can find us on our Discord server or on our IRC channel (#citra @ Libera.Chat).
+
To those of you who made it to the end, thanks for reading! We have many more exciting things to tell you all about in the future, so stay tuned!
Hey there, Citra fans! (We haven’t used that one for a while, have we?)
+
You’ve all wanted it and we’ve heard your cries and pleas. Vulkan has arrived and is here to stay, available now in the latest Citra release!
+
Why Vulkan?
+
Since the dawn of time — well, since Citra’s creation — many, many users have requested we add support for the Vulkan Graphics API; providing better performance in many cases and better support on devices, especially Android. There’s a lot to love, but oh boy, was it ever a challenge!
+ Vulkan on Intel Core i3-1005G1.FPS: 115 Speed: 193%
+
+
+
+
+
+
+
+
+
Vulkan support is also becoming a standard feature across many emulators, such as Dolphin, Ryujinx, RPCS3, yuzu, and many others.
+As we’ve mentioned before, Citra is heading into the modern age. OpenGL is considered an ageing graphics API, with buggy and slow drivers, and performance bottlenecks. A modern graphics API like Vulkan is perfect for our vision of the New™️ Citra.
+
If you haven’t read it already, we have posted a detailed teaser about Vulkan in Citra in our 2020 Q2 ~ 2023 Q1 Progress Report.
+We thoroughly recommend you give that a read, as it’s a really good recap of the development of Vulkan at the time of writing.
+
Where to get Vulkan
+
If you’d rather jump straight into the action, Citra with the Vulkan renderer can be found in the latest Nightly release, either as a standalone build or from our installer.
+
What to expect
+
As with anything to do with emulation, nothing is ever perfect. Things are always evolving and changing, and this is no different.
+
Android
+
Attention Android users! We have not forgotten about you! We are still here, making your gaming experience on mobile even better!
+
A very large number of Citra users currently use a phone with a Mali GPU. This isn’t something specific to Citra users, the majority of phones currently on the market have them! Especially with Samsung phones, if you live anywhere in the world apart from the United States or China, there’s a high chance you’ll get one with a Mali GPU.
+
Sadly, these GPUs tend to have rather poor OpenGL ES drivers, so Citra’s performance on them generally left a lot to be desired and bordered on unplayable for most 3DS titles. Performance improved significantly for these devices after some of the initial rasterizer cache refactor work on our graphics backend was done, making many less demanding titles capable of reaching 100% emulation speed. However, many titles were still running short of full speed.
+
Now, these concerns can be laid to rest! Mali’s vastly better Vulkan drivers allow for better, and smoother, gameplay when using Citra’s Vulkan backend. You can now easily go beyond 100% emulation speed on most, if not all, games. And with the addition of asynchronous shader compilation, in-game stutter due to shaders building is greatly reduced, leaving you with a more seamless gameplay experience.
+
+
+
+
+
+
+
+ Just look at the difference!
+
+
+
+
+
+
If we could rewind to the terrible OpenGL ES drivers on Mali GPUs we mentioned before for a moment; another caveat of these drivers is the amount of bugs in them. This would cause graphical glitches in games, from characters being the wrong colors, to entire landscapes being rendered incorrectly.
+Of course, this would affect the gameplay just as much as poor performance would. Who wants to play a game if it doesn’t even look right?
+Thankfully, this is another area of concern that has been fixed by the Citra Vulkan backend on Android.
+
Bringing us back to the first ever game Citra launched, The Legend of Zelda: Ocarina of Time 3D is one such game that has graphical glitches caused by the Mali OpenGL ES drivers fixed with Vulkan:
+
+
+
+
+
+
+
+ We've been waiting for you, Hero of Time.
+
+
+
+
+
+
macOS
+
Great news for macOS (Apple Silicon and Intel) users! Citra once again fully supports macOS devices!
+
“Well, what does that have to do with Vulkan?” one might ask…
+
The answer is a bit complicated.
+Citra used to require only OpenGL 3.3 in order to run, which macOS still technically supports. However, after many revisions of our graphics backend, that requirement was upped to at least OpenGL 4.3. Unlike all other major operating systems, Apple decided to deprecate OpenGL support. This means that macOS does not support anything beyond OpenGL 4.1, which doesn’t meet Citra’s new requirements. As such, Citra could no longer run on macOS.
+
“Does macOS support Vulkan then?” another might ask…
+
Sadly, the answer to that is a “no”. Apple, in their infinite wisdom, decided to create a proprietary graphics API called “Metal”, and wants all apps to use that instead. However, that would require us to create a graphics backend that is only relevant for macOS, and no other platform. Given Citra’s cross-platform nature, that wouldn’t be ideal. There is a solution though: MoltenVK. This is a translation layer that translates Vulkan calls into Metal calls. Through this translation, Citra can run on macOS once again!
+
To use Vulkan, go to Citra > Preferences > Graphics > Advanced tab and set the Graphics API option to Vulkan. Additionally, the long-standing white/grey-screen bug, that required you to resize your Citra window in order to see anything being rendered, has been fixed with this API!
+
AMD
+
There is another group of users that will benefit greatly from Vulkan. Namely, Windows users with older AMD GPUs.
+
A while back, AMD massively improved their notoriously bad OpenGL drivers. This improvement saw those AMD GPU users, who were struggling to hit 100% emulation speed before, suddenly achieving up to 10 times that emulation speed. Whilst this was incredible news for AMD users, there was a caveat to this: only GCN 4.0 GPUs and newer received these improved drivers. For anyone using an older AMD GPU architecture, they are still stuck on the old, and really bad, OpenGL drivers.
+
Luckily for them, the Vulkan drivers on those GPUs are still pretty good! As such, they’ll no longer have to deal with sub-par performance, and can even compete with the new kids in performance!
+
What NOT to expect
+
Keep in mind that Vulkan is a very new, and very big, addition to Citra. There are bound to be many bugs and glitches that slipped through the cracks. However, we’ve tried to make sure that what renders properly in OpenGL, renders properly in Vulkan. If you find a title where that isn’t the case, please do let us know! With your testing and reports, we’ll keep working to improve our Vulkan backend!
+
Some quick notes:
+
+
+
Do not expect Vulkan to fix old emulation bugs that are not related to graphics or rendering.
+
+
+
Do not expect Vulkan to render games correctly that our OpenGL backend does not render correctly. Aside from OpenGL or Vulkan driver bugs, switching between the APIs shouldn’t show any visual difference. If that is the case for you, please report this to us!
+
+
+
Do not expect Vulkan to be an improvement over OpenGL in every aspect, on every device. Whilst Vulkan provides better performance than OpenGL in most cases, that is not always the case.
+
+
+
As of writing, Vulkan does not have full feature parity with our OpenGL backend. We will list some of the missing features below.
+
+
+
Whilst Vulkan currently has a disk pipeline cache, as well as runtime shader caching, an actual Disk Shader Cache for it is not yet implemented. As such, you may still experience some shader stutter at the start of each session until that is properly implemented.
+
+
+
Recording your gameplay using Video Dumping is not yet implemented.
+
+
+
Texture Filtering and Post-Processing Shaders are not yet implemented.
As with our OpenGL backend, we have minimum hardware requirements for running Vulkan.
+
Any device that supports Vulkan 1.1 or above will work with our Vulkan backend. Be it macOS, AMD, or Android. As long as your device supports this, you’re good to go!
+However, there is an exception for Adreno 5xx devices on Android, as these GPUs do not work with our Vulkan implementation at this time. We’ll be working to fix this with future updates, so keep your eyes peeled!
+
What’s next?
+
As mentioned, our Vulkan backend does not yet have full feature parity with our OpenGL backend. Once that parity is achieved, we plan on giving you a much more technical article about the entire Vulkan backend, sure to satisfy the curious among you.
+
We hope this release excites you about the future of Citra as much as it excites us.
+Our greatest gratitude goes out to the countless developers involved in bringing Vulkan to Citra, but especially to GPUCode. Without him, none of this would ever have been possible.
+We also express thanks to Steveice10, who helped on the macOS side of things for the Vulkan release, and to BreadFish64 for his expertise with Vulkan from his previous attempt to bring Vulkan to Citra.
As game compatibility has broadened and the popularity of Citra has risen there’s always been a lack of consistent
+information on what could be played in Citra and what couldn’t. Often times the best way to find out if a game was
+working properly in Citra was to jump in and test it for yourself, but if any issues were encountered you’d be left
+scouring through forums sifting through potentially out of date information for answers.
+
In order to address this issue Flame Sage,
+Flamboyant Ham,
+leo121,
+anodium, and
+TheKoopaKingdom have worked hard to create a new game
+compatibility wiki! As time goes on more and more titles from the 3DS library will be added to this list. As they’re
+added in, each game will be given a compatibility rating based on how well and how smoothly they run in Citra. On each
+game’s individual page there will be a summary of the game itself, how it runs on Citra, as well as any problems that
+arise when running the game.
+
We encourage community contributions to this list as well! If you’d like to add new entries to this list you can find
+out how to contribute here.
+
Thank you everyone for continuing on this journey with us!
Special thanks must be given to fincs and the rest of the 3DS community for their work reverse-engineering the DSP
+firmware. Without that work, Citra would not be this far with audio emulation.
+
As of May 19th, 2016, Citra now
+has preliminary High Level Emulation (HLE) audio support! This means that users playing on Citra no longer have to
+listen to the deafening sound of silence in many titles. To get to this point was a huge reverse-engineering effort
+done by multiple people, with much of the reverse-engineering and the final implementation for Citra coming from
+MerryMage. This undertaking has required many months of development but the end result brings sound to the masses.
+
+
+
+
+
+
Technical Details on how Audio Works for the 3DS
+
Audio processing and output is done by a specialised coprocessor. These kinds of coprocessors are called Digital Signal
+Processors (DSPs).
+
Games that run on the 3DS need to communicate with the DSP in order to play audio. They do this by two ways: via the
+the dsp::DSP service and via a shared memory region. The dsp::DSP service provides service calls for initialization
+of the DSP hardware including firmware upload. The shared memory region is used for communication between the game on
+the CPU and the firmware on the DSP.
+
In order to emulate audio, Citra must emulate the dsp::DSP service and also understand the layout of the DSP shared
+memory region. One must understand what writing to various addresses in the shared memory region does. One must also
+understand what happens between data being fed to the DSP firmware and audio coming out of the speakers.
+
Early Reverse Engineering
+
With this known MerryMage set out to trace reads and writes to shared memory that games did. She eventually ended up
+playing these back on hardware and figured out what the appropriate firmware responses were. This eventually lead to
+the early implementations of audio output that originally were shown in January by various users. Many other aspects,
+including ADPCM decoding, took a while to figure out.
+
+
+
+
+
+
MerryMage had raw audio output working but she still didn’t understand how various parameters were applied to the audio
+by the firmware. It was at this point where she discovered that the firmware writes back what is output to the speakers
+into the shared memory region. This discovery made future work with audio effects much easier as bit perfect audio
+could be dumped as the 3DS produced it without any extra hardware. Having real hardware audio output on hand meant
+MerryMage could also apply signal processing techniques like system identification to figure out what internal
+processing the firmware does.
+
With this newfound knowledge and this new set of tools MerryMage rapidly conquered what the firmware was doing.
+
Time Stretching
+
Emulation speed can vary a lot between games or even parts of games. To accomodate this, time streching was added as an
+audio enhancement. This post-processing effect adjusts audio speed to match emulation speed and helps prevent audio
+stutter. This is an effect completely separate from emulation and is only to alter and improve audio played back when
+the emulator is not going full speed.
+
Future Plans for Audio
+
Audio is still not complete! There are still a number of unimplemented features and accuracy improvements to have. Many
+of these features have been reverse engineered already but simply aren’t implemented. This includes reverb, delay, and
+other minor audio effects. Some features require more reverse engineering work, such as looped buffers and surround
+sound.
+
While the black-box reverse engineering approach has served well so far, further improvements in accuracy can more
+easily be made by decompiling the firmware and perhaps implementing Low Level Emulation (LLE) audio. This comes with
+its own set of challenges especially as the DSP architecture is not well known and there is little documentation on it.
+
Until then, we at Citra hope that everyone enjoys this initial HLE audio implementation!
Realtime performance comparison with framelimit off
+
Very fast. Test results across various computers show that it averages out to be a 2x speed boost.
+With the new update, Citra will use much more of your GPU, removing some of the dependence on a CPU with high single-core performance.
+As always, the actual difference will vary by game and by your specific hardware configuration!
+In celebration of this massive improvement, we wanted to share some of the successes and struggles we’ve had over the years with the hardware renderer.
+
Brief History of Citra’s Rendering Backends
+
Back in early 2015, Citra was still a young emulator, and had just barely started displaying graphics for the first time.
+In a momentous occasion, Citra displayed 3D graphics from a commercial game, Legend of Zelda: Ocarina of Time 3D
+
+
+
+
+
+
+
+
+
+
+
+
+ It took a year from when citra started to get to this point
+
+
+
+
+
+
This engineering feat was thanks to the hard work of many contributors in both the emulator scene and the 3ds hacking scene, who worked tirelessly to reverse engineer the 3DS GPU, a chip called the PICA200.
+But not even a few months later, Citra was able to play the game at full speed!
+
+
+
+
+
+
+
+
+
+
+
+
+ Good thing that shield flashing bug still isn’t around
+
+
+
+
+
+
Why is there such a major difference in speed from the first and the second video?
+The speed difference boils down to how the 3DS GPU is being emulated.
+The first video is showing off the software renderer, which emulates the PICA200 by using your computer’s CPU.
+On the other hand, the second video is using the OpenGL hardware renderer, which emulates the PICA200 by using your computer’s GPU.
+From those videos, using your GPU to emulate the 3DS GPU is the clear winner when it comes to speed!
+However, it’s not all sunshine and daisies; there’s always tradeoffs in software development.
+
Challenges in the Hardware Renderer
+
Earlier it was stated that the OpenGL hardware renderer was emulating the PICA200 by using the GPU instead of the CPU, and … that’s only partially true.
+As it stands, only a portion of the PICA200 emulation is running on the GPU; most of it is running on the CPU!
+To understand why, we need to dive a little deeper into the difference between CPUs and modern GPUs.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The green shaded portions are what Citra emulates using the GPU. For a hardware renderer, Citra isn’t using the GPU much!
+
+
+
+
+
+
As a general rule of thumb, CPUs are fast at computing general tasks, while GPUs are blazing fast at computing very specific tasks.
+Whenever the tasks the PICA200 can perform matches up with tasks you can do on a GPU using OpenGL, everything is fast and everyone is happy!
+That said, we tend to run into edge cases that the PICA200 supports, but frankly, OpenGL is not well suited to support.
+This leads to cases where sometimes we just have to live with minor inaccuracies as a tradeoff for speed.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The infamous Pokémon outlines bug was one such example of something that OpenGL just doesn’t handle well
+
+
+
+
+
+
OpenGL is also great for emulator developers because it’s a cross-platform standard for graphics, with support for all major desktop platforms.
+But because OpenGL is just a specification, every vendor is left up to their own to make their drivers support the specification for every individual platform.
+This means performance and features can vary widely between operating systems, graphics driver, and the physical graphics card.
+As you might have guessed, this leads to some OS specific bugs that are very hard to track down.
+In the linked issue, only on Mac OSX, Citra would leak memory from the hardware renderer.
+We traced it back to how textures were juggled between the 3DS memory and the host GPU, but we don’t have many developers that use Mac, so we never did find the root cause.
+For a little bit of good news, this is fixed in the latest nightly, but only because the entire texture handling code was rewritten!
+
Moving Forward with the Hardware Renderer: Cleaning up Texture Forwarding
+
Despite the issues mentioned above, OpenGL has been a fair choice for a hardware renderer, and phantom has been hard at work improving the renderer.
+Their first major contribution was a massive, complete rewrite of the texture forwarding support that was added back in 2016.
+The new texture forwarding code increases the speed of many games, and fixes upscaled rendering in some other games as well.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Metroid: Samus Returns heavily used a PICA200 feature that had a comment // TODO: implement this in the hardware renderer
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Writing that missing method fixed upscaling while making the game much faster
+
+
+
+
+
+
Whenever a texture is used in the hardware renderer, the hardware renderer will try to use a copy of the texture already in the GPU memory, but if that fails, it has to reload the texture from the emulated 3DS memory.
+This is called a texture upload, and it’s slow for a good reason.
+The communication between CPU and GPU is optimized for large amounts of data transferred, but as a tradeoff, it’s not very fast.
+This works great for PC games, where you know all the textures you want to upload ahead of time and can send them in one large batch, but ends up hurting performance for Citra since we can’t know in advance when the emulated game will do something that requires a texture upload.
+
The texture forwarding rewrite increases the speed of many games by adding in new checks to avoid this costly synchronization of textures between emulated 3DS memory and the host GPU memory.
+Additionally, the new texture forwarding can avoid even more texture uploads by copying the data from any compatible locations.
+As an extension of this feature, phantom went the extra mile and fixed Pokémon outlines as well!
+Pokémon games would draw the outline by reinterpreting the depth and stencil buffer as an RGBA texture, using the value for the red color to draw the outline.
+Sadly, OpenGL doesn’t let you just reinterpret like that, meaning we needed to be more creative.
+phantom worked around this limitation by copying the data into a Pixel Buffer Object, and running a shader to extract the data into a Buffer Texture which they could use to draw into a new texture with the correct format.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The long standing issue is gone!
+
+
+
+
+
+
The texture forwarding rewrite has been battle tested in Citra Canary for the last 2 months, during which time we fixed over 20 reported issues.
+We are happy to announce that it’s now merged into the master branch, so please enjoy the new feature in the latest nightly build!
+
The Big News You’ve Been Waiting For
+
A few paragraphs ago, we mentioned that Citra’s hardware renderer did most of the emulation on the CPU, and only some of it on the GPU.
+The big news today is Citra now does the entire GPU emulation on the host GPU.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Just look at all that green for each pipeline stage!
+
+
+
+
+
+
With an unbelievable amount of effort, phantom has done it again.
+Moving the rest of the PICA200 emulation to the GPU was always a sort of “white whale” for Citra.
+We knew it would make things fast, but the sheer amount of effort required to make this happen scared off all those who dared attempt it.
+But before we get into why this was so challenging, let’s see some real performance numbers!
+
All testing was done with the following settings: 4x Internal Resolution, Accurate Hardware Shaders On, Framelimit Off
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Dedicated GPUs saw the biggest improvement
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Mid-High end GPUs tend to be fast
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Low-Mid end GPUs are just a bit fast
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ According to telemetry data, Pokémon is the most played game on Citra
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ But Monster Hunter is catching up in playtime
+
+
+
+
+
+
Obstacles to Emulating the PICA200 on a GPU
+
Making Functions Out of GOTOs
+
It’s likely that the game developers for the 3DS didn’t have to write PICA200 GPU assembly, but when emulating the PICA200, all Citra can work with is a commandlist and a stream of PICA200 opcodes.
+While the developers probably wrote in a high level shader language that supports functions, when the shaders are compiled, most of that goes away.
+The PICA200 supports barebones CALL, IF, and LOOP operations, but also supports an arbitrary JMP that can go to any address.
+Translating PICA200 shaders into GLSL (OpenGL Shader Language) means that you’ll have to be prepared to rewrite every arbitrary JMP without using a goto as GLSL doesn’t support them.
+
phantom assumed the worst when they originally translated PICA200 shaders into GLSL and wrote a monstrous switch statement that would have a case for every jump target and act as a PICA200 shader interpreter.
+This worked, but proved to be slower than the software renderer!
+Now that phantom knew it was possible, and they had some data about how the average PICA200 shader looked, they took to rewrite it with the goal to make it fast.
+While the shaders could theoretically be very unruly and hard to convert, almost all the shaders were well behaved, presumably because they are compiled from a higher level language.
+This time around, phantom generated native GLSL functions wherever possible by analyzing the control flow of the instructions, and the results are much prettier and faster.
+Armed with the new knowledge, phantom rewrote the conversion a third time, and optimized the generated shaders even further.
+What started off slower than the software renderer ended up being the massive performance boost we have today!
+
Multiplication Shouldn’t Be This Slow
+
When converting from PICA200 shaders into GLSL, there are a few PICA200 opcodes that should just match up without any issues.
+Addition, subtraction, and multiplication should … wait. Where did this issue come from?
+ Off: Oh. Well maybe Eren looks better this way
+
+
+
+
+
+
+
+
+
It turns out that the PICA200 multiplication opcode has a few edge cases that don’t impact a large majority of games, and leads to some hilarious results in others.
+On the PICA200, infinity * 0 = 0 but in OpenGL infinity * 0 = NaN and this can’t be configured.
+In the generated GLSL shaders, phantom emulates this behavior by making a function call instead of a simple multiplication.
Alas, it’s a performance penalty to use a function everywhere instead of regular multiplication.
+On weaker GPUs, we noticed the penalty is so severe, we actually made this configurable.
+The whole point of a hardware renderer is to be fast, so eating a penalty when only a small handful of games need this level of accuracy would be regrettable.
+You can turn off this feature in the settings by deselecting “Accurate Hardware Shader” and get a noticeable performance boost, but be aware that a few games will break in strange ways!
+
Finding Bugs and Working Overtime
+
We were very excited to launch this feature when phantom declared that it was ready; results from user testing were entirely positive, and the performance improvements were unbelievable, but one thing stood in the way.
+No one had yet tested to see if it worked on AMD GPUs.
+We called for our good friend JMC47 to break out the AMD card he uses for testing Dolphin, and Citra crashed the driver! Oh no!
+
From JMC47’s time in Dolphin, he’s made a few friends here and there, and he found someone willing to investigate.
+After a few gruelling weeks, JonnyH was able to narrow down what the problem is, and luckily it’s not a bug in the AMD drivers.
+It turns out that it’s a bug in the GL specification, or more precisely, the exact issue is ambiguous wording.
+glDrawRangeElementsBaseVertex states that the indices should be a pointer, but doesn’t say whether the pointer should be to CPU memory or GPU memory.
+Citra passed a pointer to CPU memory without a second thought, as both Nvidia and Intel drivers seemed fine with it, but AMD drivers are strict.
+As a workaround, phantom added support for streaming storage buffers, which allows Citra to work with the data on the CPU and sync it with the GPU when it’s time to draw.
+
It’s a challenge to support all of the many GPUs out there, and we’ve put in so much work to ensure that this new feature will run on as many hardware configurations as possible.
+But it’s very likely that there will be some GPUs that do not fully support the new hardware renderer, and so we added another option in the Configuration to allow users to turn this feature off entirely.
+Simply changing the “Shader Emulation” from “GPU” to “CPU” will revert to using the same old CPU shaders that Citra was using before.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Check out the new Renderer settings in the Graphics tab
+
+
+
+
+
+
What’s next
+
While today marks a victory for fast emulation, we always have room for improvement.
+As explained earlier in the article, getting OpenGL to work consistently across all platforms and GPUs is surprisingly challenging, so be ready for bugs.
+This isn’t the end for the hardware renderer, but a wonderful boost to one of Citra’s more complicated features.
+There is always something more that can be done to make the hardware renderer even faster and more accurate (contributions welcome!), but in the meantime, we hope you enjoy playing even more games at full speed!
Hey there, Citra fans! (We haven’t used that one for a while, have we?)
+You’ve all wanted it and we’ve heard your cries and pleas. Vulkan has arrived and is here to stay, available now in the latest Citra release!
+Why Vulkan? Since the dawn of time — well, since Citra’s creation — many, many users have requested we add support for the Vulkan Graphics API; providing better performance in many cases and better support on devices, especially Android.
Doesn’t it feel like it was just yesterday when Citra released its first progress report in years? It certainly was exciting, finally reaching a point of having tangible progress and being able to share it with everyone! As we said in the previous progress report, Citra is alive and well, and as a result, we have even more Citra improvements to talk about. So, dear reader, it’s time for another progress report which is sure to excite you!
Welcome back to another Citra Mega Progress Report!
+Yes! We aren’t dead! First off, we do apologize for the wait, we are still lacking a full-time writer. In the meantime, Citra community moderator autumnburra and developer FearlessTobi have come together with the assistance of another community moderator, SleepingSnake, to provide you, the Citra community, with this awesome report on all the changes we’ve had in Citra since 2020 Q2!
+If you have been keeping up to date with messages posted in the #development channel in our Discord server, you may already be aware of some of these.
Hey there, Citra fans! It’s been a few months since our Android version released and its reception has been absolutely wonderful. We wanted to take this opportunity to make an announcement and answer a few questions many of you have had.
+App Installs Citra Android has now reached 500,000+ installs on the Google Play Store!
+This is an absolutely incredible achievement and your enthusiasm is a big factor in what drives development of the app.
It has been more than a year since the last progress report, not for lack of progress, but for lack of writers. To fill in the gap, developers jroweboy and FearlessTobi independently wrote drafts for a new progress report, and another developer zhaowenlan1779 merged their works and added more content. Together, we are able to present you with an update on all the changes we’ve had since 2019 Q1.
+Since it has been such a long time since the last one, you may already be very familiar with several of these features, but there are also a few here that we haven’t announced until now!
Hello there emulation aficionados!
+Today we are unveiling the most requested addition for Citra: Android Support!
+That’s right, you can finally play 3DS games on the go!
Hey there, Citra fans! These past 6 months have been crazily exciting, and simply wonderful for Citra overall.
+We’ve made major breakthroughs which were long overdue.
+New features, bug fixes, performance improvements, improved game compatibility, and much more await you.
+So buckle up and enjoy the ride!
Hello everyone to the summer (or winter, for those on the southern half of this Earth) edition of Citra’s progress reports. Although not very many large changes have been made, many fixes have focused on accuracy improvements and implementing some of the sorely needed user experience features.
+Before we go further into this, our Patreon poll results are out. We asked our patrons, which feature they would like to see us work on next and they delivered.
It’s finally happening folks: The Citra Team would like to announce that we now have a project-wide Patreon. This will be a way for you, our users, to donate directly to the Citra developers, in support of their efforts to continue to make Citra the best option available to enjoy 3DS games. Patreon will be yet another way for our biggest fans to contribute to the project.
+Become a Patron !
Emulators grow quickly. Last month alone, there were 39 pull requests
+merged to Citra. For this reason, it’s important to be able to manage the many different
+versions of an emulator. Until now however, Citra has had no installer or updater
+for the nightly builds. Although
+the now obsolete Bleeding Edge builds
+did have both of these things, it was limited to Windows, and the installer framework
+had some issues that restricted what we could do with it.
More info on the Canary version of Citra will be in the September 2017 Progress
+Report.
+
Installer
+
The new installer is an application
+separate from Citra itself, that utilizes the Qt Installer Framework
+(Also known as QtIFW.) to download the latest version of either Citra
+Nightly or Citra Canary from our website’s repository and extract it to your system’s
+program directory.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ CHOOSE YOUR WEAPON
+
+
+
+
+
+
Additionally, depending on which build(s) you chose, the installer
+will also create desktop icons for easy access. You can get the installer from the
+downloads page, which will try to automatically
+select the correct version for your OS.
+
Updater
+
In addition to installing, QtIFW also provides functionality for updating via the
+maintenancetool utility. For convenience, this is integrated into the Qt frontend
+(The main GUI that you probably use.) in the form of scheduled automatic
+updates. You can optionally check for updates on startup, and/or check for updates
+on shutdown.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Note the two checkboxes in the updates section.
+
+
+
+
+
+
If an update is found at startup, you will be asked if you want to run the updater
+or not.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Gotta keep your Citrus fresh!
+
+
+
+
+
+
If an update is found at shutdown, Citra will silently update without prompting,
+because at this point emulation has already been terminated.
+
You can also manually update your Citra installation at any time, by going to the
+Help menu, and then Check for Updates.
+
Uninstallation & Install Modification
+
QtIFW’s maintenancetool can also be used to uninstall Citra, and install a different
+type of build. Like the updater, this is also integrated into the Qt frontend, and
+can be accessed by going to the Help menu, and then Modify Citra Install. Integrating
+with an already well-established framework like QtIFW allows us to streamline the
+task of installation maintenence.
DISCLAIMER: You do NOT need to follow this guide if you downloaded Citra for the first time after December 6th, 2016
+OR if you have freshly installed Citra since using an older build.
+
In new versions of Citra, the location of saves has changed, so this guide will show how to migrate your saves to the
+new location on Windows (Linux and macOS Bleeding Edge builds are planned, we are currently busy working on bringing
+nightly builds back.).
+
+
Press Windows + R, type explorer %localappdata%, this should bring up a Windows Explorer window in a Local
+folder. Navigate to the citra folder.
+
+
+
+
+
+
+
+
+
+
+
Navigate to the app-x.x.x folder with the highest version number.
+
+
+
+
+
+
+
+
+
+
+
+
Move the user` folder to your desktop. Make sure the user folder no longer exists in the existing folder.
+
+
+
Run citra-qt.exe`. The settings should now be reset, and Citra will begin using the new location. Now you can exit
+it.
+
+
+
Press Windows + R, type explorer %appdata%, this should bring up a Windows Explorer window in a Roaming folder.
+Navigate to the Citra folder.
+
+
+
Move the contents of the user folder on your desktop to the Citra folder, overwrite any files if asked.
+
+
+
Now, all of your settings and saves for Citra have been moved to the new location, which has the advantage of being able
+to be accessed by any new version of Citra, bringing stability improvements and storing your user data in a safe place.
It’s been a while folks - since the last report, we have had many new features come to Citra. Some notable ones include multiplayer improvements, hardware shader improvements (post GLvtx), a logging system rewrite, and the highly coveted camera support. Our continuous integration (CI) systems were optimized as well. Apart from these, we have had many more minor features, improvements, and bug fixes. So, without further ado let’s get right into it:
New year, new changes in Citra. Specifically, lots of technical changes under the hood, from applets to IPC, have made Citra even more accurate and laid a foundation for even more goodies the next year. With many great changes all around, this article is going to be packed to the brim with all the new goodies that have come to Citra during those crimson months.
+But, enough faffing about! Let’s get right into it:
Winter arrives once more, and like I mentioned in August’s progress report, I am extremely excited for what’s in store. In fact, many of the really big goodies I’ve decided to seperate to their own articles, which should be coming up in the next few weeks.
+There’s also been many changes this month that improve the speed of emulation across the board, on top of the usual improvements in accuracy and features.
Networked Multiplayer is one of those features that was so surprising to see, that the lucky few chosen to test it were wondering if it was real. For the past year, several developers have banded together to bring this amazing implementation of online play to Citra.
+The Nintendo 3DS heavily relies on wireless for its slew of multiplayer compatible titles. Considering that so many games feel empty without their multiplayer features, we’re excited to announce that in select titles, you’ll be able to play together with your friends across the world in the latest Canary builds of Citra!
Emulators grow quickly. Last month alone, there were 39 pull requests merged to Citra. For this reason, it’s important to be able to manage the many different versions of an emulator. Until now however, Citra has had no installer or updater for the nightly builds. Although the now obsolete Bleeding Edge builds did have both of these things, it was limited to Windows, and the installer framework had some issues that restricted what we could do with it.
2017 has been an amazing year, with more work having been put into the project than ever before, but it’s not over yet! Last we met was June, and just two months later the Citra issue tracker is brimming with lots of changes once more. I am extremely excited for this month (and what’s coming up the next few months) but we’re getting ahead of ourselves! On this progress report, let’s check out the big fish in the July and August pond of patches!
Citra has some issues, and by its nature as an open source project, they are visible to everyone and fixable by anyone. Unfortunately though, most contributions are made by a small minority of developers. These developers have found it difficult to prioritize their efforts, since the majority of issue reports are written scattered across Discord, Reddit, forums, IRC, and too many other places to count.
+Because of this, the Citra team has put together a framework to report data about how Citra is used to our server, and use that data to discover what are the most popular games and hardware configurations, where emulated games crash in Citra most often, and more.
The summer of 2017 has just rolled in, and although we don’t have a summer of code, the patches continue rolling in regardless. We’ve got a ton of fixes this month in the renderer, so this report is going to be very screenshot heavy. With that out of the way, let’s get right to it. Implemented Procedural Texture (Texture Unit 3) by wwylele There is a rarely used feature in the 3DS’ GPU called procedural textures, “proctex” for short.
As game compatibility has broadened and the popularity of Citra has risen there’s always been a lack of consistent information on what could be played in Citra and what couldn’t. Often times the best way to find out if a game was working properly in Citra was to jump in and test it for yourself, but if any issues were encountered you’d be left scouring through forums sifting through potentially out of date information for answers.
In the last quarter, we’ve further improved the speed and accuracy of citra along with supporting more 3DS features, and we are very excited to show what we’ve been working on. It’s a bit hard to believe, but Citra is already three years old, and in these three years we’ve gone from an emulator that could barely run homebrew, to one that can run many commercially available games at playable speeds!
As we approach the first birthday of Citra’s website, we’d like to announce yet another project infrastructure update:
+We’ve decided to launch a new forum based on the Discourse forum software!
+When we first introduced the new website back in February of 2016, we chose to use Flarum over more classic forums used on other websites (such as phpBB, MyBB, or vBulletin). The reason for this was because Flarum was a much more modern platform, with better mobile support, and a attractive and innovative UI.
As you all know, the Nightly builds have been down for some time now due to the former maintainer not being around, but the issues have been resolved, and the Nightly builds are now available on our downloads page once again! With downloads available for Windows, macOS, and Linux, you’re no longer required to compile the build yourself.
+Likewise, we’d like to remind all users that any bugs found within Citra, or during emulation, be reported from the Nightly builds, and not the Bleeding Edge ones.
DISCLAIMER: You do NOT need to follow this guide if you downloaded Citra for the first time after December 6th, 2016 OR if you have freshly installed Citra since using an older build.
+In new versions of Citra, the location of saves has changed, so this guide will show how to migrate your saves to the new location on Windows (Linux and macOS Bleeding Edge builds are planned, we are currently busy working on bringing nightly builds back.
Sometimes it’s hard to wait. We’ve noticed that users are very excited about the future of Citra, which means wanting to try all of the changes all of the time. But, emulator development can be a slow, arduous process as new changes can bring big regressions and problems with the much wanted new features.
+In order to satiate the needs of our users, we’ll be adding new builds for download: bleeding edge builds!
If you haven’t heard of Discord yet, it’s basically an alternative to Skype, featuring servers with both voice and text chat. You can use it in your browser, download the desktop program, or get the mobile app.
+If you don’t have an account already, you can make one for free here.
+Once you’ve done that, you can join Citra’s official server by going here.
+There are 5 channels:
+#read-first - A read-only introduction to the server, and announcements.
Special thanks must be given to fincs and the rest of the 3DS community for their work reverse-engineering the DSP firmware. Without that work, Citra would not be this far with audio emulation.
+As of May 19th, 2016, Citra now has preliminary High Level Emulation (HLE) audio support! This means that users playing on Citra no longer have to listen to the deafening sound of silence in many titles. To get to this point was a huge reverse-engineering effort done by multiple people, with much of the reverse-engineering and the final implementation for Citra coming from MerryMage.
One of the big things everyone has been wondering about Citra is when it will be able to render games at HD resolutions. One of the great things about emulators is that they can surpass the limitations of the original console, especially when it comes to graphical fidelity. With the 3DS specifically, many beautifully detailed games are hidden behind staggeringly low resolution screens topping out at 400x240. With Texture Forwarding (from tfarley, based on yuriks early implementation), Citra can now output games at any resolution, and runs faster as well!
Welcome to the first Citra Progress Report of 2016! While 2015 will be considered the year that Citra first played games, 2016 is quickly shaping up as a year filled with higher compatibility, greater stability and much more as Citra matures. The avalanche of new features from tons of contributors has made it hard to keep up with everything even for developers!
+Because there have been so many changes and there are so many different games, it can be very hard to keep up with what is working and what is not.
This month we bring you the second installment of our two-part progress report on Citra in 2015! With this part, we discuss the evolution from Citra being able to barely run a few commercial games at a few frames-per-second, to where it is in 2016: Running many retail games at reasonable speeds, some of which are fully playable with near flawless graphics! We discuss Citra’s new “dyncom” CPU core, the OpenGL renderer, per-pixel lighting, and various bug fixes.
While Citra was first founded in April of 2014, visible progress for the emulator didn’t really happen until the turn of the year. After a long struggle to get anything to boot, 2015 saw Citra evolve from an experimental emulator that couldn’t run games into an experimental emulator that can run games. And while it may not seem like Citra is that far along, it is truly amazing how much things have progressed in just a year since the first commercial title booted.
Welcome to the brand new Citra website! This new site has been a sort of secret project off and on for over a year now. A lot of hard work, a few false starts, but here we are! This has been a big team effort - we’d like to especially thank Flame Sage, the primary architect behind the new website backend; MaJoR for the design and artwork, and lastly jchadwick for his early on role in the project.
Citra has some issues, and by its
+nature as an open source project, they are visible to everyone and fixable by
+anyone. Unfortunately though, most contributions are made by
+a small minority of developers.
+These developers have found it difficult to prioritize their efforts, since the
+majority of issue reports are written scattered across Discord, Reddit, forums,
+IRC, and too many other places to count.
+
Because of this, the Citra team has put together a framework to report data about
+how Citra is used to our server, and use that data to discover what are the most
+popular games and hardware configurations, where emulated games crash in Citra
+most often, and more. We had considered including this in last month’s progress
+report, but we decided that it would be best to publish this on its own, so it
+gets the attention it deserves. We’re very aware that privacy is important to
+many of our users, and so from the earliest planning stage we knew we must be as
+transparent and open about this as possible.
+
The telemetry framework will collect information such as:
+
+
Information about the version of Citra you are using
+
Performance data for the games you play
+
Your Citra configuration settings
+
Information about your computer hardware (e.g. GPU, CPU, and OS type)
+
Emulation errors and crash information
+
+
Not everyone is comfortable sharing information about their system, so we’ve made it easy to opt-out:
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ First, head to the Citra “Emulation” → “Configure…” menu.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Then, head into the “Web” tab.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ And finally, untick the box titled “Share anonymous usage data with the Citra team”.
+
+
+
+
+
+
You may have also noticed the field titled “Telemetry ID” in the screenshots, this
+is an identifier generated randomly on install which is used instead of your IP
+address. This makes data collection entirely anonymous, unless you choose to log in.
+You can also reset your telemetry ID if you’d like by clicking “Regenerate”. The
+new ID will also be completely random, and so it would be treated as a wholly new
+identity.
+
Telemetry is an extremely useful developer tool, as they allow the developer to
+be more aware of the users’ needs and priorities accurately, rather than guessing.
+But it is only as useful as the data obtained, which is why we urge users to not
+opt-out, so the data can be as accurate and correct as possible. Just as innacurate
+measurements can damage a device during calibration, innacurate statistical data
+will only cause damage to Citra.
One of the big things everyone has been wondering about Citra is when it will be able to render games at HD resolutions.
+One of the great things about emulators is that they can surpass the limitations of the original console, especially
+when it comes to graphical fidelity. With the 3DS specifically, many beautifully detailed games are hidden behind
+staggeringly low resolution screens topping out at 400x240. With Texture Forwarding (from tfarley, based on
+yuriks early implementation), Citra can now output games at any resolution, and runs faster as well!
+
+
+
+
+
+
What is Texture Forwarding?
+
To understand Texture Forwarding, we’ve created a diagram to show what’s actually going on.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
The diagram is a simplified representation of the actual pipeline, as 3DS games perform multiple additional steps such
+as framebuffer copies between rendering and display - but the concept remains the same. The main idea is to keep
+framebuffers rendered by the HW Renderer as textures on the GPU as much as possible, to avoid the performance overhead
+of transferring them between the CPU and GPU as in the Slow Path. In most instances, the CPU never accesses
+(reads from/writes to) a rendered frame so it can safely stay on the GPU from rendering all the way through to
+ultimate display in Citra. This eliminates CPU/GPU sync points and makes the emulator faster overall.
+
In addition to a performance boost, Texture Forwarding also allows the HW Renderer to render and display at higher
+resolutions than the native 3DS when the pixel data is not accessed from anywhere else. But in the event that the
+memory region of some texture is read or written by the CPU, the renderer will fall back to the slow path and
+downsample the texture back to native resolution to ensure that the accesses are reflected accurately.
As you all know, the Nightly builds have been down for some time now due to the former maintainer not being around, but
+the issues have been resolved, and the Nightly builds are now available on our
+downloads page once again! With downloads available for Windows, macOS, and Linux,
+you’re no longer required to compile the build yourself.
+
Likewise, we’d like to remind all users that any bugs found within Citra, or during emulation, be reported from the
+Nightly builds, and not the Bleeding Edge ones. From hereon out, support for the latter will no longer be given. If
+you believe you’ve found a bug in Bleeding Edge, please retest on the latest Nightly build. Thank you everyone for
+your patience, and Happy New Year!
If you haven’t heard of Discord yet, it’s basically an alternative to Skype, featuring
+servers with both voice and text chat. You can use it in your browser, download the desktop program, or get the mobile
+app.
+
If you don’t have an account already, you can make one for free here.
+
Once you’ve done that, you can join Citra’s official server by going here.
+
There are 5 channels:
+
+
#read-first - A read-only introduction to the server, and announcements.
+
#citra-general - Any discussion related to Citra.
+
#citra-support - If you are having trouble with Citra, you can ask for help here. Please read #read-first, first.
+
#dumping-support - Support for dumping games/system files for Citra.
+
#offtopic - Anything not related to Citra that doesn’t belong in #citra-general goes here.
+
+
The Citra Community Rules also apply to this server.
Welcome to the brand new Citra website! This new site has been a sort of secret project off and on for over a year now.
+A lot of hard work, a few false starts, but here we are! This has been a big team effort - we’d like to especially
+thank Flame Sage, the primary architect behind the new
+website backend; MaJoR for the design and artwork, and
+lastly jchadwick for his early on role in the project. Here’s a brief overview of some of our new features!
+
Blog: Citra now finally has a platform to share information with everyone directly! It
+will allow Citra to communicate directly to users and fans in long form, fully exploring 3DS emulation in ways that
+were impossible to express before. An article is already up talking about the past year of development, and more
+will come!
+
Community: Citra now has its own discussion forum! It is now open, so come on
+everyone and join! Instead of the typical forum software, we are using a brand new open source forum software that
+is focused on streamlining and simplifying bulletin boards. It’s a little different from what you might be used to,
+but it is a joy to use!
+
Wiki: The site has it’s own wiki! But not a mediawiki - select articles from
+Github can be elevated here for easy access to user-update guides and other materials. In time, it will make Citra
+much easier to use.
+
Screenshots: We have our own screenshots gallery, which will give us a lot
+more room for a lot more screenshots! With easy navigation and viewing to boot.
+
Logo: And finally, this is the official reveal of our new logo!
+
+
+
+
+
+
+
+
There’s a LOT more work to be done, so things are definitely a work in progress. For example, a new download page with
+archives is high on our list! But we’re going to keep working hard and keep making things better.
As we approach the first birthday of Citra’s website, we’d like to announce yet another project infrastructure update:
+
We’ve decided to launch a new forum based on the
+Discourse forum software!
+
When we first introduced the new website back in February of 2016, we chose to use Flarum over
+more classic forums used on other websites (such as phpBB, MyBB, or vBulletin). The reason for this was because Flarum
+was a much more modern platform, with better mobile support, and a attractive and innovative UI. It seemingly had a
+very promising future, receiving multiple large updates in a very short timeframe. But while it was great to use at
+first, it ultimately left us wanting some critical features that never seemed to come - such as the ability to send
+private messages.
+
Meet Discourse, an open source forum platform with the features that we need. Not only
+does it improve our ability to moderate, but the every day user experience should also be enhanced. Discourse is a
+widely used and established platform, used by such communities as Imgur,
+Twitter, Github, Ubuntu,
+and more. The layout of the new forums are simple, users of Flarum should
+have no problem getting used to it!
+
You can visit the new forums at https://community.citra-emu.org/, come say Hello! You’ll need to create a new account,
+but we now support using your Google or GitHub credentials to log in!
+ The below game article is based on user submitted content.
+ See a mistake? Want to contribute?
+ Edit this game article on Github
+
+
+
+
+
1001 Spikes
+
+
+
+
+
+
+
+
+
+
Rating
+
Not Tested The game has not yet been tested.
+
+
+
Type
+
+
+
+
+
+
Game Icon
+
+
+
+
+
+
Title IDs
+
+
+
000400000008FE00
+
+
+
+
+
System Files Required?
+
N/A
+
+
+
Shared Font Required?
+
N/A
+
+
+
+
+
+
+
+
+
Summary
+
On the Citra emulator, 1001 spikes seems to be completely broken. Upon starting the game up it immediately black screens and drops to 0 FPS. Doesn’t reach the title screen, nor give a fatal error.
+ The below game article is based on user submitted content.
+ See a mistake? Want to contribute?
+ Edit this game article on Github
+
+
+
+
+
3D Classics: Kirby's Adventure
+
+
+
+
+
+
+
+
+
+
Rating
+
Perfect Game functions flawless with no audio or graphical glitches, all tested functionality works as intended without any workarounds needed.
+
+
+
Type
+
+
+
+
+
+
Game Icon
+
+
+
+
+
+
Title IDs
+
+
+
0004000000054600
+
+
+
+
+
System Files Required?
+
N/A
+
+
+
Shared Font Required?
+
N/A
+
+
+
+
+
+
+
+
+
Summary
+
3D Classics: Kirby’s Adventure works near flawlessly in Citra. Graphically, the game suffers from minor graphical issues (e.g. Grand Wheelie sprite), but this does not hinder the gameplay in any way. The game also requires decent hardware to achieve higher frame rates.
+
+
+
+
+
+
+
Compatibility
+
+
+
+
ID
+
Build Date
+
Tested By
+
Hardware
+
Citra Version
+
Rating
+
+
+
+
+
+
+
4bdc0aad-5e08-48dd-a379-d0a9ec84635f
+
01/18/2019
+
on 01/20/2019
+
AMD Ryzen 7 1800X Eight-Core Processor Radeon RX Vega Windows
+ The below game article is based on user submitted content.
+ See a mistake? Want to contribute?
+ Edit this game article on Github
+
+
+
+
+
3D Ecco the Dolphin
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Rating
+
Perfect Game functions flawless with no audio or graphical glitches, all tested functionality works as intended without any workarounds needed.
+
+
+
Type
+
+
+
+
+
+
Game Icon
+
+
+
+
+
+
+
+
Title IDs
+
+
+
00040000000D9E00
+
+
+
+
+
System Files Required?
+
N/A
+
+
+
Shared Font Required?
+
N/A
+
+
+
+
+
+
+
+
+
Summary
+
3D Ecco the Dolphin works perfectly in Citra. There are no noticeable graphical and audio issues but may require decent hardware to achieve higher performance.
+
+
+
+
+
+
+
Compatibility
+
+
+
+
ID
+
Build Date
+
Tested By
+
Hardware
+
Citra Version
+
Rating
+
+
+
+
+
+
+
2881c5a0-1d25-4215-8789-229fb09e19d8
+
01/11/2018
+
on 01/12/2018
+
Intel(R) Core(TM) i7-6700K CPU @ 4.00GHz GeForce GTX 1060 3GB/PCIe/SSE2 Windows
+ The below game article is based on user submitted content.
+ See a mistake? Want to contribute?
+ Edit this game article on Github
+
+
+
+
+
3D Sonic The Hedgehog
+
+
+
+
+
+
+
+
+
+
Rating
+
Great Game functions with minor graphical or audio glitches and is playable from start to finish. May require some workarounds.
+
+
+
Type
+
+
+
+
+
+
Game Icon
+
+
+
+
+
+
Title IDs
+
+
+
00040000000DA000
+
+
+
+
+
System Files Required?
+
N/A
+
+
+
Shared Font Required?
+
N/A
+
+
+
+
+
+
+
+
+
Summary
+
3D Sonic The Hedgehog has some problems in Citra. Graphically, the game does suffer some issues, especially with Sonic’s sprites and other sprites having a blue box around it, though to get full speed does require a good computer. It suffers these issues but they aren’t game breaking. There is a chance the game might crash though most likely later in the game than Green Hill Zone.
+
+
+
+
+
+
+
Compatibility
+
+
+
+
ID
+
Build Date
+
Tested By
+
Hardware
+
Citra Version
+
Rating
+
+
+
+
+
+
+
1b0c6d75-875d-46c3-9918-334864e12f87
+
03/11/2021
+
on 03/23/2021
+
Intel(R) Core(TM) i7-6700 CPU @ 3.40GHz GeForce RTX 2060/PCIe/SSE2 Windows
+ The below game article is based on user submitted content.
+ See a mistake? Want to contribute?
+ Edit this game article on Github
+
+
+
+
+
7th Dragon III Code: VFD
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Rating
+
Perfect Game functions flawless with no audio or graphical glitches, all tested functionality works as intended without any workarounds needed.
+
+
+
Type
+
+
+
+
+
+
Game Icon
+
+
+
+
+
+
+
+
Title IDs
+
+
+
000400000018F800
+
+
+
+
+
System Files Required?
+
N/A
+
+
+
Shared Font Required?
+
N/A
+
+
+
+
+
+
+
+
+
Summary
+
7th Dragon III Code: VFD has some problems in Citra. Graphically, the game suffers from minor issues, and requires powerful hardware to obtain near full speed. Text fields are misaligned, texture forwarding (internal resolution settings) only affects character models and certain effects. It suffers from no observed audio issues.
+
+
+
+
+
+
+
Compatibility
+
+
+
+
ID
+
Build Date
+
Tested By
+
Hardware
+
Citra Version
+
Rating
+
+
+
+
+
+
+
044b1983-7418-48a4-ad6c-ed8416749dd0
+
12/18/2019
+
on 12/22/2019
+
Intel(R) Core(TM) i5-4690 CPU @ 3.50GHz Intel(R) HD Graphics 4600 Windows
+ The below game article is based on user submitted content.
+ See a mistake? Want to contribute?
+ Edit this game article on Github
+
+
+
+
+
Animal Crossing: Happy Home Designer
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Rating
+
Great Game functions with minor graphical or audio glitches and is playable from start to finish. May require some workarounds.
+
+
+
Type
+
+
+
+
+
+
Game Icon
+
+
+
+
+
+
+
+
Title IDs
+
+
+
000400000014F100
+
+
+
+
+
System Files Required?
+
N/A
+
+
+
Shared Font Required?
+
N/A
+
+
+
+
+
+
+
+
+
Summary
+
Animal Crossing: Happy Home Designer works perfectly in Citra. There are no graphical glitches or audio issues. The game is fully playable but may require decent hardware to obtain full speed.
+
+
+
+
+
+
+
Compatibility
+
+
+
+
ID
+
Build Date
+
Tested By
+
Hardware
+
Citra Version
+
Rating
+
+
+
+
+
+
+
0958941d-b986-4fa1-9f7d-cce85b97528c
+
05/11/2020
+
on 05/20/2020
+
Intel(R) Core(TM) i3-5005U CPU @ 2.00GHz GeForce 920MX/PCIe/SSE2 Windows
+
Nightly Build d11d600
+
Great
+
+
+
+
574e4231-424b-4b06-8fd3-be1ca3796771
+
07/7/2020
+
on 07/07/2020
+
AMD Ryzen 5 3500U with Radeon Vega Mobile Gfx AMD Radeon(TM) Vega 8 Graphics Windows
+
Canary Build 22d2281
+
Perfect
+
+
+
+
73896e6b-5901-48c3-9c19-f0a1c04bb39c
+
07/6/2021
+
on 07/08/2021
+
Intel(R) Core(TM) i5-10400 CPU @ 2.90GHz GeForce GTX 1660 SUPER/PCIe/SSE2 Windows
+ The below game article is based on user submitted content.
+ See a mistake? Want to contribute?
+ Edit this game article on Github
+
+
+
+
+
Asterix The Mansions of the Gods
+
+
+
+
+
+
+
+
+
+
Rating
+
Not Tested The game has not yet been tested.
+
+
+
Type
+
+
+
+
+
+
Game Icon
+
+
+
+
+
+
Title IDs
+
+
+
0004000000150C00
+
+
+
+
+
System Files Required?
+
N/A
+
+
+
Shared Font Required?
+
N/A
+
+
+
+
+
+
+
+
+
Summary
+
Asterix is works fine in Citra with no major problems.. The only issue is that to get sound to come through speakers you need to click on configure emulator and click okay. Additionally, the special effect sounds are really loud where the background music is quite.
+ The below game article is based on user submitted content.
+ See a mistake? Want to contribute?
+ Edit this game article on Github
+
+
+
+
+
ATTACK OF THE FRIDAY MONSTERS! A TOKYO TALE
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Rating
+
Okay Game functions with major graphical or audio glitches, but game is playable from start to finish with workarounds.
+
+
+
Type
+
+
+
+
+
+
Game Icon
+
+
+
+
+
+
+
+
Title IDs
+
+
+
00040000000E7600
+
+
+
+
+
System Files Required?
+
N/A
+
+
+
Shared Font Required?
+
N/A
+
+
+
+
+
+
+
+
+
Summary
+
Attack of the Friday Monsters! A Tokyo Tale works well in Citra. The game runs great at full speed even on modest hardware aside from slightly choppy and slow FMVs.
Azure Striker Gunvolt - Striker Pack runs near perfection. It has some audio and little graphic issues and in-game slow downs on low end hardware, while the story parts runs perfectly. The final battle requires the player to sing a song on the microphone, so the game is unbeatable right now since the microphone feature is unimplemented.
+ The below game article is based on user submitted content.
+ See a mistake? Want to contribute?
+ Edit this game article on Github
+
+
+
+
+
Batman: Arkham Origins Blackgate
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Rating
+
Bad Game functions, but with major graphical or audio glitches. Unable to progress in specific areas due to glitches even with workarounds.
+
+
+
Type
+
+
+
+
+
+
Game Icon
+
+
+
+
+
+
+
+
Title IDs
+
+
+
00040000000D6B00
+
+
+
+
+
System Files Required?
+
N/A
+
+
+
Shared Font Required?
+
N/A
+
+
+
+
+
+
+
+
+
Summary
+
Batman: Arkham Origins Blackgate runs near flawlessly in Citra, although the framerate can be a little bumpy at times. Powerful hardware recommended. It have some audio issues and in-game slow downs on low end hardware, while the story parts runs perfectly.
+
+
+
+
+
+
+
Compatibility
+
+
+
+
ID
+
Build Date
+
Tested By
+
Hardware
+
Citra Version
+
Rating
+
+
+
+
+
+
+
16409e4c-683e-4eca-a66a-3182815d1d89
+
09/13/2018
+
on 09/23/2018
+
Intel(R) Core(TM) i7-4790 CPU @ 3.60GHz AMD Radeon (TM) R9 380 Series Windows
+ The below game article is based on user submitted content.
+ See a mistake? Want to contribute?
+ Edit this game article on Github
+
+
+
+
+
Bike Rider DX
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Rating
+
Not Tested The game has not yet been tested.
+
+
+
Type
+
+
+
+
+
+
Game Icon
+
+
+
+
+
+
+
+
Title IDs
+
+
+
00040000000FC000
+
+
+
+
+
System Files Required?
+
N/A
+
+
+
Shared Font Required?
+
N/A
+
+
+
+
+
+
+
+
+
Summary
+
Bike Rider DX has some problems in Citra. Graphically, the game suffers from minor issues due to the lack of Geometry Shaders. It suffers from minor audio issues at times, but this does not hinder gameplay in any way.
+ The below game article is based on user submitted content.
+ See a mistake? Want to contribute?
+ Edit this game article on Github
+
+
+
+
+
Brain Age: Concentration Training
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Rating
+
Perfect Game functions flawless with no audio or graphical glitches, all tested functionality works as intended without any workarounds needed.
+
+
+
Type
+
+
+
+
+
+
Game Icon
+
+
+
+
+
+
+
+
Title IDs
+
+
+
00040000000B3C00
+
+
+
+
+
System Files Required?
+
N/A
+
+
+
Shared Font Required?
+
N/A
+
+
+
+
+
+
+
+
+
Summary
+
Brain Age: Concentration Training runs great on citra, it may stutter and/or slowdown during new menu animations and transitions, specially when Dr. kawashima is on screen. some puzzles/games are unplayable due to requiring microphone capabilities.
+
+
+
+
+
+
+
Compatibility
+
+
+
+
ID
+
Build Date
+
Tested By
+
Hardware
+
Citra Version
+
Rating
+
+
+
+
+
+
+
63c545d6-d495-4d52-a14c-97cc4c1875ce
+
04/17/2019
+
on 04/21/2019
+
Intel(R) Core(TM) i7-6700HQ CPU @ 2.60GHz GeForce GTX 960M/PCIe/SSE2 Windows
+
Nightly Build 0ec45f6
+
Great
+
+
+
+
bb032e61-2123-4b92-8978-26a9e2837377
+
09/5/2018
+
on 09/11/2018
+
Intel(R) Core(TM) i5-5200U CPU @ 2.20GHz GeForce 820M/PCIe/SSE2 Windows
+
Canary Build 6766faf
+
Great
+
+
+
+
bb632e14-9436-47b0-be65-22e4f9b52974
+
09/10/2019
+
on 09/20/2019
+
Intel(R) Core(TM) i5-3470 CPU @ 3.20GHz GeForce GTX 1050/PCIe/SSE2 Windows
+
Nightly Build d6f2bc8
+
Perfect
+
+
+
+
e54f0148-fe6b-42d6-b171-81944e8db31d
+
08/1/2018
+
on 08/04/2018
+
Intel(R) Core(TM) i3-6006U CPU @ 2.00GHz Intel(R) HD Graphics 520 Windows
+ The below game article is based on user submitted content.
+ See a mistake? Want to contribute?
+ Edit this game article on Github
+
+
+
+
+
Bravely Default
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Rating
+
Perfect Game functions flawless with no audio or graphical glitches, all tested functionality works as intended without any workarounds needed.
+
+
+
Type
+
+
+
+
+
+
Game Icon
+
+
+
+
+
+
+
+
Title IDs
+
+
+
00040000000FC500
+
+
+
+
+
System Files Required?
+
N/A
+
+
+
Shared Font Required?
+
N/A
+
+
+
+
+
+
+
+
+
Summary
+
Bravely Default works well in Citra. Graphically, the game is considered perfect. The audio is nearly perfect, but changing voice localization options in-game will cause the game to freeze (It does not do that anymore). The game also performs well on semi-decent hardware.
+
+
+
+
+
+
+
Compatibility
+
+
+
+
ID
+
Build Date
+
Tested By
+
Hardware
+
Citra Version
+
Rating
+
+
+
+
+
+
+
18a5cbdb-dab2-4097-b820-dd8871f5fbe3
+
03/6/2021
+
on 03/26/2021
+
AMD Ryzen 3 3250U with Radeon Graphics AMD Radeon(TM) Graphics Windows
+
Nightly Build 8e3c767
+
Perfect
+
+
+
+
302a00c3-e920-4585-b605-e92e0b7ab66f
+
07/11/2021
+
on 07/18/2021
+
Intel(R) Core(TM) i5-4210U CPU @ 1.70GHz NVIDIA GeForce 840M/PCIe/SSE2 Windows
+ The below game article is based on user submitted content.
+ See a mistake? Want to contribute?
+ Edit this game article on Github
+
+
+
+
+
BRAVELY SECOND: END LAYER
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Rating
+
Great Game functions with minor graphical or audio glitches and is playable from start to finish. May require some workarounds.
+
+
+
Type
+
+
+
+
+
+
Game Icon
+
+
+
+
+
+
+
+
Title IDs
+
+
+
000400000017BA00
+
+
+
+
+
System Files Required?
+
N/A
+
+
+
Shared Font Required?
+
N/A
+
+
+
+
+
+
+
+
+
Summary
+
Bravely Second: End Layer works very well in Citra. There are however slow downs when opening a menu (such as the save menu) and also during transitions from places to another. Audio also seems to be in sync.
+
+
+
+
+
+
+
Compatibility
+
+
+
+
ID
+
Build Date
+
Tested By
+
Hardware
+
Citra Version
+
Rating
+
+
+
+
+
+
+
336804ff-ae92-49f5-962d-54a9909f7b41
+
01/5/2021
+
on 01/17/2021
+
Intel(R) Core(TM) i5-7600K CPU @ 3.80GHz GeForce GTX 1060 6GB/PCIe/SSE2 Windows
+
Nightly Build e33677b
+
Great
+
+
+
+
54807c11-5919-42be-85ad-71c02814ccc5
+
11/12/2020
+
on 11/12/2020
+
Intel(R) Core(TM) i7-7700K CPU @ 4.20GHz GeForce RTX 2070 SUPER/PCIe/SSE2 Windows
+ The below game article is based on user submitted content.
+ See a mistake? Want to contribute?
+ Edit this game article on Github
+
+
+
+
+
Captain Toad: Treasure Tracker
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Rating
+
Great Game functions with minor graphical or audio glitches and is playable from start to finish. May require some workarounds.
+
+
+
Type
+
+
+
+
+
+
Game Icon
+
+
+
+
+
+
+
+
Title IDs
+
+
+
00040000001CB100
+
+
+
+
+
System Files Required?
+
N/A
+
+
+
Shared Font Required?
+
N/A
+
+
+
+
+
+
+
+
+
Summary
+
Captain Toad: Treasure Tracker works near flawlessly on Citra. The game performs well on decent hardware, however, there are some slowdowns while loading or in areas with many objects.
+
+
+
+
+
+
+
Compatibility
+
+
+
+
ID
+
Build Date
+
Tested By
+
Hardware
+
Citra Version
+
Rating
+
+
+
+
+
+
+
287d7d91-48e9-4199-865e-ab3cbbd299fd
+
02/12/2021
+
on 02/21/2021
+
Intel(R) Core(TM) i5-4300M CPU @ 2.60GHz Intel(R) HD Graphics 4600 Windows
+
Canary Build 1d1f601
+
Perfect
+
+
+
+
30bfcc32-6025-44be-ad29-e2b8b547155b
+
02/21/2021
+
on 03/03/2021
+
Intel(R) Core(TM) i7-7700K CPU @ 4.20GHz GeForce GTX 1060 6GB/PCIe/SSE2 Windows
+ The below game article is based on user submitted content.
+ See a mistake? Want to contribute?
+ Edit this game article on Github
+
+
+
+
+
Castlevania: Lords of Shadow - Mirror of Fate
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Rating
+
Bad Game functions, but with major graphical or audio glitches. Unable to progress in specific areas due to glitches even with workarounds.
+
+
+
Type
+
+
+
+
+
+
Game Icon
+
+
+
+
+
+
+
+
Title IDs
+
+
+
0004000000096600
+
+
+
+
+
System Files Required?
+
N/A
+
+
+
Shared Font Required?
+
N/A
+
+
+
+
+
+
+
+
+
Summary
+
Castlevania Lords Of Shadow - Mirror of Fate runs very slow on Citra. The game is supposed to run at 60FPS and Citra can push itself to run at 30FPS best during actual gameplay which makes this game run at 49% and thus the game running in slow motion.
+ The below game article is based on user submitted content.
+ See a mistake? Want to contribute?
+ Edit this game article on Github
+
+
+
+
+
Cave Story
+
+
+
+
+
+
+
+
+
+
Rating
+
Great Game functions with minor graphical or audio glitches and is playable from start to finish. May require some workarounds.
+
+
+
Type
+
+
+
+
+
+
Game Icon
+
+
+
+
+
+
Title IDs
+
+
+
000400000009B300
+
+
+
+
+
System Files Required?
+
N/A
+
+
+
Shared Font Required?
+
N/A
+
+
+
+
+
+
+
+
+
Summary
+
Sound effects sometimes only play once, sometimes doesn’t even play at all
+Examples: Water in first cave doesn’t make a sound unless it’s the first time it’s played, Weapons only play their sound once, jumping doesn’t even play the sound for it same goes for hitting the top of a block.
+
+
+
+
+
+
+
Compatibility
+
+
+
+
ID
+
Build Date
+
Tested By
+
Hardware
+
Citra Version
+
Rating
+
+
+
+
+
+
+
19c957d6-21a0-4152-a4a8-76d74afb6696
+
05/24/2019
+
on 05/27/2019
+
Intel(R) Celeron(R) CPU J1900 @ 1.99GHz Intel(R) HD Graphics Windows
+
Canary Build dc05af0
+
Perfect
+
+
+
+
4556fd93-b934-4be1-bca2-05dc51f4bd72
+
11/14/2018
+
on 11/16/2018
+
AMD A4-4000 APU with Radeon(tm) HD Graphics AMD Radeon HD 7480D Windows
+
Canary Build 7b57994
+
Perfect
+
+
+
+
577ea175-5af4-43be-a55b-da5057362d84
+
03/14/2019
+
on 03/14/2019
+
Intel(R) Core(TM) i7-7500U CPU @ 2.70GHz Intel(R) HD Graphics 620 Windows
+
Canary Build 224b159
+
Perfect
+
+
+
+
6a9fa86a-d36b-485f-b5aa-ea67858e8570
+
01/2/2019
+
on 01/05/2019
+
Intel(R) Core(TM) i5-8300H CPU @ 2.30GHz GeForce GTX 1050 Ti/PCIe/SSE2 Windows
+
Canary Build 11c5c74
+
Great
+
+
+
+
9a73a9cd-df2f-4943-b127-b6186d16409b
+
04/8/2019
+
on 04/08/2019
+
Intel(R) Core(TM) i3-6100U CPU @ 2.30GHz Intel(R) HD Graphics 520 Windows
+ The below game article is based on user submitted content.
+ See a mistake? Want to contribute?
+ Edit this game article on Github
+
+
+
+
+
Code of Princess
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Rating
+
Great Game functions with minor graphical or audio glitches and is playable from start to finish. May require some workarounds.
+
+
+
Type
+
+
+
+
+
+
Game Icon
+
+
+
+
+
+
+
+
Title IDs
+
+
+
00040000000A2C00
+
+
+
+
+
System Files Required?
+
N/A
+
+
+
Shared Font Required?
+
N/A
+
+
+
+
+
+
+
+
+
Summary
+
Code of Princess runs perfectly on Citra, until you want to try local game, or network one. But aside of that, you can perfecly complete the game, it suffers of slow downs on low end hardware and little audio issues. Graphics looks pixelated on any resolution.
+ The below game article is based on user submitted content.
+ See a mistake? Want to contribute?
+ Edit this game article on Github
+
+
+
+
+
Corpse Party
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Rating
+
Not Tested The game has not yet been tested.
+
+
+
Type
+
+
+
+
+
+
Game Icon
+
+
+
+
+
+
+
+
Title IDs
+
+
+
0100F7E01343E000
+
+
+
+
+
System Files Required?
+
N/A
+
+
+
Shared Font Required?
+
N/A
+
+
+
+
+
+
+
+
+
Summary
+
Corpse Party has no problems in Citra. Graphically, the game works fine. It has no audio issues.
+i5-7400 CPU @ 3.00GHz"
+date = “2019-07-20T21:21:52.618”
+gpu = “Intel(R) HD Graphics 630”
+id = “050a0bf1-6cd9-4d9a-8682-f604098d0f52”
+os = “Windows”
+program_id = “0004000000194200”
+version = “a9df1c2”
+ The below game article is based on user submitted content.
+ See a mistake? Want to contribute?
+ Edit this game article on Github
+
+
+
+
+
Crashmo
+
+
+
+
+
+
+
+
+
+
Rating
+
Perfect Game functions flawless with no audio or graphical glitches, all tested functionality works as intended without any workarounds needed.
+
+
+
Type
+
+
+
+
+
+
Game Icon
+
+
+
+
+
+
Title IDs
+
+
+
00040000000B6E00
+
+
+
+
+
System Files Required?
+
N/A
+
+
+
Shared Font Required?
+
N/A
+
+
+
+
+
+
+
+
+
Summary
+
Crashmo doesn’t have any issues in Citra. It is not very demanding and can run on nearly all hardware and runs at full speed without any graphical issues.
+
+
+
+
+
+
+
Compatibility
+
+
+
+
ID
+
Build Date
+
Tested By
+
Hardware
+
Citra Version
+
Rating
+
+
+
+
+
+
+
5e2f90e1-8c57-4a0a-928c-b31b8a1d231a
+
03/21/2020
+
on 03/24/2020
+
Intel(R) Core(TM) i5-7200U CPU @ 2.50GHz Intel(R) HD Graphics 620 Windows
+ The below game article is based on user submitted content.
+ See a mistake? Want to contribute?
+ Edit this game article on Github
+
+
+
+
+
Culdcept Revolt
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Rating
+
Great Game functions with minor graphical or audio glitches and is playable from start to finish. May require some workarounds.
+
+
+
Type
+
+
+
+
+
+
Game Icon
+
+
+
+
+
+
+
+
Title IDs
+
+
+
00040000001BEC00
+
+
+
+
+
System Files Required?
+
N/A
+
+
+
Shared Font Required?
+
N/A
+
+
+
+
+
+
+
+
+
Summary
+
The game runs rather well for the most part, and it is possible to play normally. However, accessing the internal help system will freeze the game (the music continues to play) and the only way out of it is closing Citra and opening it again.
+ The below game article is based on user submitted content.
+ See a mistake? Want to contribute?
+ Edit this game article on Github
+
+
+
+
+
DEAD OR ALIVE Dimensions
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Rating
+
Great Game functions with minor graphical or audio glitches and is playable from start to finish. May require some workarounds.
+
+
+
Type
+
+
+
+
+
+
Game Icon
+
+
+
+
+
+
+
+
Title IDs
+
+
+
0004000000034F00
+
+
+
+
+
System Files Required?
+
N/A
+
+
+
Shared Font Required?
+
N/A
+
+
+
+
+
+
+
+
+
Summary
+
Dead or Alive: Dimensions has no graphical or audio issues. The game can run full speed in the main menu and most combat stages. It doesn’t require powerful hardware to run.
+
+
+
+
+
+
+
Compatibility
+
+
+
+
ID
+
Build Date
+
Tested By
+
Hardware
+
Citra Version
+
Rating
+
+
+
+
+
+
+
08a15c4a-e5c7-4b85-a290-826ffa07b33e
+
02/13/2019
+
on 02/14/2019
+
Intel(R) Xeon(R) CPU E5-2678 v3 @ 2.50GHz Quadro P5000/PCIe/SSE2 Windows
+ The below game article is based on user submitted content.
+ See a mistake? Want to contribute?
+ Edit this game article on Github
+
+
+
+
+
Dedede’s Drum Dash Deluxe
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Rating
+
Perfect Game functions flawless with no audio or graphical glitches, all tested functionality works as intended without any workarounds needed.
+
+
+
Type
+
+
+
+
+
+
Game Icon
+
+
+
+
+
+
+
+
Title IDs
+
+
+
0004000000147A00
+
+
+
+
+
System Files Required?
+
N/A
+
+
+
Shared Font Required?
+
N/A
+
+
+
+
+
+
+
+
+
Summary
+
Dedede’s Drum Dash Deluxe functions flawlessly in Citra. The graphics and audio are considered perfect, and the game performs well on lower-end hardware.
+
+
+
+
+
+
+
Compatibility
+
+
+
+
ID
+
Build Date
+
Tested By
+
Hardware
+
Citra Version
+
Rating
+
+
+
+
+
+
+
40bece65-a752-4f99-893e-a6dc2887dffe
+
02/13/2019
+
on 02/15/2019
+
Intel(R) Xeon(R) CPU E5-2678 v3 @ 2.50GHz Quadro P5000/PCIe/SSE2 Windows
+ The below game article is based on user submitted content.
+ See a mistake? Want to contribute?
+ Edit this game article on Github
+
+
+
+
+
Detective Pikachu
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Rating
+
Okay Game functions with major graphical or audio glitches, but game is playable from start to finish with workarounds.
+
+
+
Type
+
+
+
+
+
+
Game Icon
+
+
+
+
+
+
+
+
Title IDs
+
+
+
00040000001C1E00
+
+
+
+
+
System Files Required?
+
N/A
+
+
+
Shared Font Required?
+
N/A
+
+
+
+
+
+
+
+
+
Summary
+
Detective Pikachu runs great on good hardware. It had an issue with fmv’s playing faster than the framerate which is unintended. But that is fixed now because of LLE DSP implementation. The cutscenes run smoothly now and slowdowns should not be expected if you have a good hardware.
+
+
+
+
+
+
+
Compatibility
+
+
+
+
ID
+
Build Date
+
Tested By
+
Hardware
+
Citra Version
+
Rating
+
+
+
+
+
+
+
108bdbe2-0b53-4c5a-923a-b5091a79a235
+
02/12/2021
+
on 02/13/2021
+
Intel(R) Core(TM) i5-4570T CPU @ 2.90GHz Intel(R) HD Graphics 4600 Windows
+ The below game article is based on user submitted content.
+ See a mistake? Want to contribute?
+ Edit this game article on Github
+
+
+
+
+
Disney Epic Mickey: Power of Illusion
+
+
+
+
+
+
+
+
+
+
Rating
+
Great Game functions with minor graphical or audio glitches and is playable from start to finish. May require some workarounds.
+
+
+
Type
+
+
+
+
+
+
Game Icon
+
+
+
+
+
+
Title IDs
+
+
+
00040000000A2D00
+
+
+
+
+
System Files Required?
+
N/A
+
+
+
Shared Font Required?
+
N/A
+
+
+
+
+
+
+
+
+
Summary
+
Disney Epic Mickey: Power of Illusion works perfectly on the nightly build 1629 of Citra. No additional settings or configurations need to be changed. The average FPS is about 60 frames per second.
+ The below game article is based on user submitted content.
+ See a mistake? Want to contribute?
+ Edit this game article on Github
+
+
+
+
+
Dr. Mario: Miracle Cure
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Rating
+
Perfect Game functions flawless with no audio or graphical glitches, all tested functionality works as intended without any workarounds needed.
+
+
+
Type
+
+
+
+
+
+
Game Icon
+
+
+
+
+
+
+
+
Title IDs
+
+
+
000400000013BB00
+
+
+
+
+
System Files Required?
+
N/A
+
+
+
Shared Font Required?
+
N/A
+
+
+
+
+
+
+
+
+
Summary
+
Dr. Mario: Miracle Cure works near flawlessly in Citra. The graphics and audio are considered perfect, and the game performs well even on lower-end hardware. However local and online modes don"t work in Citra!
+
+
+
+
+
+
+
Compatibility
+
+
+
+
ID
+
Build Date
+
Tested By
+
Hardware
+
Citra Version
+
Rating
+
+
+
+
+
+
+
0bb17c7e-d7ba-42e9-9c67-d1ec5cf23d6f
+
02/9/2019
+
on 02/27/2019
+
Intel(R) Core(TM) i5-7200U CPU @ 2.50GHz Intel(R) HD Graphics 620 Windows
+ The below game article is based on user submitted content.
+ See a mistake? Want to contribute?
+ Edit this game article on Github
+
+
+
+
+
DRAGON BALL Z: Extreme Butoden Update
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Rating
+
Not Tested The game has not yet been tested.
+
+
+
Type
+
+
+
+
+
+
Game Icon
+
+
+
+
+
+
+
+
Title IDs
+
+
+
0004000E0016CD00
+
+
+
+
+
System Files Required?
+
N/A
+
+
+
Shared Font Required?
+
N/A
+
+
+
+
+
+
+
+
+
Summary
+
Dragon Ball Z: Extreme Butōden runs well in Citra. Graphically, there are no noticeable issues, and can achieve full speed on low-end hardware. It suffers from minor audio issues at times, but this does not hinder gameplay in any way.
+ The below game article is based on user submitted content.
+ See a mistake? Want to contribute?
+ Edit this game article on Github
+
+
+
+
+
Dragon Quest VII: Fragments of the Forgotten Past
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Rating
+
Great Game functions with minor graphical or audio glitches and is playable from start to finish. May require some workarounds.
+
+
+
Type
+
+
+
+
+
+
Game Icon
+
+
+
+
+
+
+
+
Title IDs
+
+
+
000400000018EF00
+
+
+
+
+
System Files Required?
+
N/A
+
+
+
Shared Font Required?
+
N/A
+
+
+
+
+
+
+
+
+
Summary
+
Dragon Quest® VII Fragments of the Forgotten Past runs well in Citra. However the game requires powerful hardware in order to run at a decent framerate.
+
+
+
+
+
+
+
Compatibility
+
+
+
+
ID
+
Build Date
+
Tested By
+
Hardware
+
Citra Version
+
Rating
+
+
+
+
+
+
+
2f419819-b171-4efe-887e-06d71d28705f
+
09/13/2019
+
on 09/16/2019
+
Intel(R) Core(TM) i3-3240 CPU @ 3.40GHz Radeon(TM) RX 460 Graphics Windows
+
Canary Build 11e556a
+
Perfect
+
+
+
+
56b55afc-bbf8-4b58-858b-3a72d70b1f42
+
08/14/2019
+
on 08/22/2019
+
Intel(R) Core(TM) i7-7700HQ CPU @ 2.80GHz GeForce GTX 1060/PCIe/SSE2 Windows
+
Nightly Build fa6b570
+
Great
+
+
+
+
5dc58ca9-ccd8-4cbe-ab21-109d1029eec1
+
08/21/2019
+
on 08/24/2019
+
Intel(R) Core(TM) i7-7700 CPU @ 3.60GHz GeForce GTX 1060 3GB/PCIe/SSE2 Windows
+ The below game article is based on user submitted content.
+ See a mistake? Want to contribute?
+ Edit this game article on Github
+
+
+
+
+
Dragon Quest VIII: Journey of the Cursed King
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Rating
+
Okay Game functions with major graphical or audio glitches, but game is playable from start to finish with workarounds.
+
+
+
Type
+
+
+
+
+
+
Game Icon
+
+
+
+
+
+
+
+
Title IDs
+
+
+
000400000018F100
+
+
+
+
+
System Files Required?
+
N/A
+
+
+
Shared Font Required?
+
N/A
+
+
+
+
+
+
+
+
+
Summary
+
Dragon Quest VIII Journey of the Cursed King works near flawlessly in Citra although the framerate can be a little bumpy at times. Powerful hardware recommended.
+ The below game article is based on user submitted content.
+ See a mistake? Want to contribute?
+ Edit this game article on Github
+
+
+
+
+
Etrian Odyssey 2 Untold: The Fafnir Knight
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Rating
+
Perfect Game functions flawless with no audio or graphical glitches, all tested functionality works as intended without any workarounds needed.
+
+
+
Type
+
+
+
+
+
+
Game Icon
+
+
+
+
+
+
+
+
Title IDs
+
+
+
000400000015F200
+
+
+
+
+
System Files Required?
+
N/A
+
+
+
Shared Font Required?
+
N/A
+
+
+
+
+
+
+
+
+
Summary
+
Etrian Odyssey 2 Untold runs with few problems in Citra. However, some GPU’s have experienced errors with hardware shaders enabled. If you expereince distorted graphics on enemy sprites, disable hardware shaders.
+
Known affected GPU models as of 9/12/2018 are:
+AMD Radeon RX570
+
+
+
+
+
+
+
Compatibility
+
+
+
+
ID
+
Build Date
+
Tested By
+
Hardware
+
Citra Version
+
Rating
+
+
+
+
+
+
+
21f3dfb5-8919-4c6e-aa59-bdf4101f4535
+
11/18/2018
+
on 11/19/2018
+
Intel(R) Core(TM) i7-2600 CPU @ 3.40GHz GeForce GTX 570/PCIe/SSE2 Windows
+ The below game article is based on user submitted content.
+ See a mistake? Want to contribute?
+ Edit this game article on Github
+
+
+
+
+
Etrian Odyssey IV: Legends of the Titan
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Rating
+
Perfect Game functions flawless with no audio or graphical glitches, all tested functionality works as intended without any workarounds needed.
+
+
+
Type
+
+
+
+
+
+
Game Icon
+
+
+
+
+
+
+
+
Title IDs
+
+
+
00040000000BD300
+
+
+
+
+
System Files Required?
+
N/A
+
+
+
Shared Font Required?
+
N/A
+
+
+
+
+
+
+
+
+
Summary
+
Etrian Odyssey IV: Legends of the Titan has some problems in Citra. Graphically, the game suffers from minor issues, but requires fairly powerful hardware to obtain near full speed. It suffers from minor audio issues at times, but this does not hinder gameplay in any way.
+
+
+
+
+
+
+
Compatibility
+
+
+
+
ID
+
Build Date
+
Tested By
+
Hardware
+
Citra Version
+
Rating
+
+
+
+
+
+
+
089e49d7-7fe6-4ab2-89de-3549a69f7b6f
+
08/1/2021
+
on 08/05/2021
+
Intel(R) Core(TM) i7-10510U CPU @ 1.80GHz NVIDIA GeForce MX110/PCIe/SSE2 Windows
+
Nightly Build dfd7926
+
Perfect
+
+
+
+
0ce92c0a-75a0-4265-8c53-a6bc5b2d8218
+
08/18/2019
+
on 08/20/2019
+
Intel(R) Core(TM) i5-8300H CPU @ 2.30GHz GeForce GTX 1050/PCIe/SSE2 Windows
+
Nightly Build 1cf75e5
+
Perfect
+
+
+
+
5b4eaae9-c7cb-4b8d-8ddf-92eac34fbb31
+
08/18/2019
+
on 08/19/2019
+
Intel(R) Core(TM) i5-8300H CPU @ 2.30GHz GeForce GTX 1050/PCIe/SSE2 Windows
+
Nightly Build 1cf75e5
+
Great
+
+
+
+
5d9652c4-37ed-4652-ace5-7d6f9ea75abe
+
08/1/2021
+
on 08/05/2021
+
Intel(R) Core(TM) i7-10510U CPU @ 1.80GHz NVIDIA GeForce MX110/PCIe/SSE2 Windows
+
Nightly Build dfd7926
+
Perfect
+
+
+
+
6a2be206-d422-4341-895e-7c2b7ea52cca
+
04/3/2021
+
on 04/12/2021
+
Intel(R) Core(TM) i7-8750H CPU @ 2.20GHz GeForce GTX 1060/PCIe/SSE2 Windows
+ The below game article is based on user submitted content.
+ See a mistake? Want to contribute?
+ Edit this game article on Github
+
+
+
+
+
Etrian Odyssey Nexus
+
+
+
+
+
+
+
+
+
+
Rating
+
Perfect Game functions flawless with no audio or graphical glitches, all tested functionality works as intended without any workarounds needed.
+
+
+
Type
+
+
+
+
+
+
Game Icon
+
+
+
+
+
+
Title IDs
+
+
+
00040000001D4E00
+
+
+
+
+
System Files Required?
+
N/A
+
+
+
Shared Font Required?
+
N/A
+
+
+
+
+
+
+
+
+
Summary
+
Etrian Odyssey Nexus works perfectly on Citra. There are some slow framerates on some cutscenes, but nothing too major.
+
Minor Issues
+
On some cases, having Keen Eye and/or big maps such as B3F Lush Woodlands completely mapped would cause the game to slowdown, unless you restart the game.
+
+
+
+
+
+
+
Compatibility
+
+
+
+
ID
+
Build Date
+
Tested By
+
Hardware
+
Citra Version
+
Rating
+
+
+
+
+
+
+
184f8df0-5881-41e3-9e94-9a376c68af3b
+
03/29/2020
+
on 03/30/2020
+
Intel(R) Core(TM) i7-4790K CPU @ 4.00GHz GeForce GTX 1060 6GB/PCIe/SSE2 Windows
+
Nightly Build 680ef64
+
Bad
+
+
+
+
1a4e55cc-24e0-4b41-b9bf-8f96faad9d78
+
10/9/2020
+
on 10/11/2020
+
AMD Phenom(tm) 8450 Triple-Core Processor GeForce GT 620/PCIe/SSE2 Windows
+
Canary Build f9e7514
+
Okay
+
+
+
+
23772607-24da-44a3-a38e-98c322977b9a
+
07/1/2020
+
on 07/03/2020
+
Intel(R) Core(TM) i7-6700HQ CPU @ 2.60GHz GeForce GTX 960M/PCIe/SSE2 Windows
+ The below game article is based on user submitted content.
+ See a mistake? Want to contribute?
+ Edit this game article on Github
+
+
+
+
+
Etrian Odyssey Untold: The Millennium Girl
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Rating
+
Perfect Game functions flawless with no audio or graphical glitches, all tested functionality works as intended without any workarounds needed.
+
+
+
Type
+
+
+
+
+
+
Game Icon
+
+
+
+
+
+
+
+
Title IDs
+
+
+
00040000000EC700
+
+
+
+
+
System Files Required?
+
N/A
+
+
+
Shared Font Required?
+
N/A
+
+
+
+
+
+
+
+
+
Summary
+
Etrian Odyssey Untold runs well on Citra with middling hardware, with no significant defects of note. Previous versions of Citra reported some defects of ‘pink snow’ on the touchscreen, but it is unclear if this still affects some GPU’s.
+
If your audio is stuttering, turn off “Enable audio stretching” in Emulation > Configure > Audio.
+
+
+
+
+
+
+
Compatibility
+
+
+
+
ID
+
Build Date
+
Tested By
+
Hardware
+
Citra Version
+
Rating
+
+
+
+
+
+
+
17c20ddf-26d0-4f11-89b2-d3665b4038bb
+
11/20/2018
+
on 11/21/2018
+
Intel(R) Core(TM) i5-4200M CPU @ 2.50GHz AMD Radeon HD 8600/8700M Windows
+
Nightly Build aa168b4
+
Great
+
+
+
+
18fbb6a4-60f7-4463-a719-c926d93c4015
+
02/21/2021
+
on 03/01/2021
+
Intel(R) Core(TM) i7-10510U CPU @ 1.80GHz GeForce MX110/PCIe/SSE2 Windows
+
Nightly Build c2d36cd
+
Perfect
+
+
+
+
234cdbeb-e170-4a72-a9c9-39f95549541d
+
05/24/2019
+
on 05/29/2019
+
Intel(R) Core(TM) i3-6100U CPU @ 2.30GHz GeForce 940MX/PCIe/SSE2 Windows
+
Nightly Build 186ffc2
+
Great
+
+
+
+
303812c0-1108-4bbf-92b9-ee08db700824
+
02/21/2021
+
on 02/26/2021
+
Intel(R) Core(TM) i7-10510U CPU @ 1.80GHz GeForce MX110/PCIe/SSE2 Windows
+
Nightly Build c2d36cd
+
Perfect
+
+
+
+
51e1796f-69b2-4526-a992-7890d7179dd0
+
11/24/2018
+
on 11/24/2018
+
Intel(R) Core(TM) i3-8350K CPU @ 4.00GHz GeForce GTX 1060 6GB/PCIe/SSE2 Windows
+
Nightly Build 210e558
+
Perfect
+
+
+
+
6960e19b-70bd-4109-8c4c-0419cdfd031d
+
02/21/2021
+
on 02/26/2021
+
Intel(R) Core(TM) i7-10510U CPU @ 1.80GHz GeForce MX110/PCIe/SSE2 Windows
+
Nightly Build c2d36cd
+
Perfect
+
+
+
+
706ba355-261a-4dc4-b0a7-c2890967804e
+
11/20/2018
+
on 11/23/2018
+
Intel(R) Core(TM) i3-8350K CPU @ 4.00GHz GeForce GTX 1060 6GB/PCIe/SSE2 Windows
+ The below game article is based on user submitted content.
+ See a mistake? Want to contribute?
+ Edit this game article on Github
+
+
+
+
+
Etrian Odyssey V: Beyond the Myth
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Rating
+
Perfect Game functions flawless with no audio or graphical glitches, all tested functionality works as intended without any workarounds needed.
+
+
+
Type
+
+
+
+
+
+
Game Icon
+
+
+
+
+
+
+
+
Title IDs
+
+
+
00040000001C5100
+
+
+
+
+
System Files Required?
+
N/A
+
+
+
Shared Font Required?
+
N/A
+
+
+
+
+
+
+
+
+
Summary
+
Etrian Odyssey V: Beyond the Myth works well in Citra. During cutscenes or battles with monsters with particularly heavy effects there can be noticeable slowdown. During regular mapping, adventuring, and most combat, the game runs smoothly.
+
+
+
+
+
+
+
Compatibility
+
+
+
+
ID
+
Build Date
+
Tested By
+
Hardware
+
Citra Version
+
Rating
+
+
+
+
+
+
+
0d455047-e5e8-4d82-a38d-9d64251c49b1
+
08/1/2021
+
on 08/05/2021
+
Intel(R) Core(TM) i7-10510U CPU @ 1.80GHz NVIDIA GeForce MX110/PCIe/SSE2 Windows
+
Nightly Build dfd7926
+
Perfect
+
+
+
+
307c3f15-ce67-4095-9dd8-f62629c26e04
+
09/6/2019
+
on 09/07/2019
+
AMD Ryzen 7 3700X 8-Core Processor GeForce GTX 970/PCIe/SSE2 Windows
+ The below game article is based on user submitted content.
+ See a mistake? Want to contribute?
+ Edit this game article on Github
+
+
+
+
+
Ever Oasis
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Rating
+
Great Game functions with minor graphical or audio glitches and is playable from start to finish. May require some workarounds.
+
+
+
Type
+
+
+
+
+
+
Game Icon
+
+
+
+
+
+
+
+
Title IDs
+
+
+
00040000001A4800
+
+
+
+
+
System Files Required?
+
N/A
+
+
+
Shared Font Required?
+
N/A
+
+
+
+
+
+
+
+
+
Summary
+
Ever Oasis works very well on Citra. Performance is good and there are no known gameplay issues. The game is region-locked and will not boot with an incorrect region setting, set the region to auto-select or one that matches the game’s to avoid this issue.
+
+
+
+
+
+
+
Compatibility
+
+
+
+
ID
+
Build Date
+
Tested By
+
Hardware
+
Citra Version
+
Rating
+
+
+
+
+
+
+
43054b85-6704-445d-b2ef-bf3f07a5f26a
+
03/5/2019
+
on 03/05/2019
+
Intel(R) Core(TM) i7-7500U CPU @ 2.70GHz Intel(R) HD Graphics 620 Windows
+
Canary Build 1463105
+
Great
+
+
+
+
4e7c4115-c5bb-4ca6-a310-bf7652f6754f
+
09/28/2019
+
on 10/03/2019
+
Intel(R) Core(TM) i5-7200U CPU @ 2.50GHz Intel(R) HD Graphics 620 Windows
+
Canary Build 1460727
+
Perfect
+
+
+
+
4fc7e5af-165a-42a9-b37f-463728dde0ac
+
02/17/2019
+
on 02/18/2019
+
Intel(R) Core(TM) i5-6300HQ CPU @ 2.30GHz GeForce GTX 960M/PCIe/SSE2 Windows
+
Nightly Build f409342
+
Perfect
+
+
+
+
56a19297-4550-45fc-a72d-fd7cd4c862b7
+
03/6/2021
+
on 03/16/2021
+
Intel(R) Core(TM) i3-8130U CPU @ 2.20GHz Intel(R) UHD Graphics 620 Windows
+
Nightly Build 8e3c767
+
Great
+
+
+
+
7fbeb1c5-3cb7-481d-bf36-b7e59b21cc4b
+
01/24/2020
+
on 01/26/2020
+
Intel(R) Core(TM) i5-6500 CPU @ 3.20GHz Radeon RX 580 Series Windows
+ The below game article is based on user submitted content.
+ See a mistake? Want to contribute?
+ Edit this game article on Github
+
+
+
+
+
Fairune
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Rating
+
Great Game functions with minor graphical or audio glitches and is playable from start to finish. May require some workarounds.
+
+
+
Type
+
+
+
+
+
+
Game Icon
+
+
+
+
+
+
+
+
Title IDs
+
+
+
0004000000158700
+
+
+
+
+
System Files Required?
+
N/A
+
+
+
Shared Font Required?
+
N/A
+
+
+
+
+
+
+
+
+
Summary
+
Fairune has some problems in Citra. Graphically, the game has seemingly no issues, and can obtain near full speed on lower-end hardware. It suffers from major audio issues at times, but this does not hinder gameplay in any way. Sound effects seem to play, but not the background music.
+ The below game article is based on user submitted content.
+ See a mistake? Want to contribute?
+ Edit this game article on Github
+
+
+
+
+
Fairune2
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Rating
+
Great Game functions with minor graphical or audio glitches and is playable from start to finish. May require some workarounds.
+
+
+
Type
+
+
+
+
+
+
Game Icon
+
+
+
+
+
+
+
+
Title IDs
+
+
+
000400000016D500
+
+
+
+
+
System Files Required?
+
N/A
+
+
+
Shared Font Required?
+
N/A
+
+
+
+
+
+
+
+
+
Summary
+
Fairune 2 has seemingly no problems in Citra. Graphically, the game has no issues, and can obtain near full speed on lower-end hardware. It suffers from minor audio issues at times, but this does not hinder gameplay in any way. Audio is quiet compared to actual hardware.
+ The below game article is based on user submitted content.
+ See a mistake? Want to contribute?
+ Edit this game article on Github
+
+
+
+
+
Fantasy Life
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Rating
+
Great Game functions with minor graphical or audio glitches and is playable from start to finish. May require some workarounds.
+
+
+
Type
+
+
+
+
+
+
Game Icon
+
+
+
+
+
+
+
+
Title IDs
+
+
+
0004000000113200
+
+
+
+
+
System Files Required?
+
N/A
+
+
+
Shared Font Required?
+
N/A
+
+
+
+
+
+
+
+
+
Summary
+
Fantasy Life has very few problems in Citra. Graphically, the game appears to suffer from little to no issues, but requires powerful hardware to obtain full speed at decent quality. It suffers from essentially no audio issues, rare stutters are not major. An issue exists where the game crashes at character creation when choosing a job as a female. Playing as a male provides a valid workaround. (This was fixed in canary)
+
Several layers of sprites are not rendered correctly, notably eye colors, however this affects very little about the functionality of gameplay. Both color selection in character creation and eye colors themselves render as white. (Previously stated to be fixed, but is still present for multiple players.)
+
+
+
+
+
+
+
Compatibility
+
+
+
+
ID
+
Build Date
+
Tested By
+
Hardware
+
Citra Version
+
Rating
+
+
+
+
+
+
+
04e6f6c0-bb95-4764-992e-0e6294ec218a
+
03/6/2021
+
on 03/23/2021
+
Intel(R) Core(TM) i7-9750H CPU @ 2.60GHz GeForce RTX 2060/PCIe/SSE2 Windows
+ The below game article is based on user submitted content.
+ See a mistake? Want to contribute?
+ Edit this game article on Github
+
+
+
+
+
Fire Emblem Awakening
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Rating
+
Great Game functions with minor graphical or audio glitches and is playable from start to finish. May require some workarounds.
+
+
+
Type
+
+
+
+
+
+
Game Icon
+
+
+
+
+
+
+
+
Title IDs
+
+
+
00040000000A0500
+
+
+
+
+
System Files Required?
+
N/A
+
+
+
Shared Font Required?
+
N/A
+
+
+
+
+
+
+
+
+
Summary
+
Fire Emblem Awakening works very well in Citra. Graphically, the game looks great when not in areas afflicted by missing geometry shaders (such as move tiles glitching); however, when in those areas (usually in-battle), major graphical issues occur, such as Chrom having blonde hair, Olivia a black dancer’s outfit, or dressing dark knights as tricksters. This game can achieve full speed on decent hardware.
+
Player experience: Really great performance, was able to finish start to finish with no issues. The only thing that might be annoying is it goes to 70% speed on cutscenes but it’s not a big deal at all. Cutscenes now run at full speed on sufficient hardware in recent Citra versions.
+
Due to Citra not supporting Spotpass data, a large portion of content will not be accessible without a save file with that content already on it.
+ The below game article is based on user submitted content.
+ See a mistake? Want to contribute?
+ Edit this game article on Github
+
+
+
+
+
Fire Emblem Echoes: Shadows of Valentia
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Rating
+
Great Game functions with minor graphical or audio glitches and is playable from start to finish. May require some workarounds.
+
+
+
Type
+
+
+
+
+
+
Game Icon
+
+
+
+
+
+
+
+
Title IDs
+
+
+
00040000001B4000
+
+
+
+
+
System Files Required?
+
N/A
+
+
+
Shared Font Required?
+
N/A
+
+
+
+
+
+
+
+
+
Summary
+
Fire Emblem Echoes: Shadows of Valentia suffers from minor graphical glitches and minor audio glitches.
+The graphical glitches are almost exclusive to dialogue, where a checkerboard pattern of slightly darker squares remains in the background. No other graphical glitches occur.
+The audio glitches are nothing more than crackling if running at 100% speed, turn on audio stretching if the game will not run at 100% speed on your device.
+
Player experience: Game is playable from start to finish without workarounds, most cutscenes run slowly, but dialogue scenes are near-perfect. All textures, models, lighting effects, and animations play without fail, with the exception of dashing in dungeons(https://github.com/citra-emu/citra/issues/5428). Amiibo functions exactly as intended. Citra will randomly decide that your emulated SD card no longer exists when attempting to load DLC.
+
Note: Use of dedicated GPU is highly recommended. Intel Integrated Graphics are typically built for efficiency and power saving.
+
Note: DLC is finicky with each and every game on the system, this error is not exclusive to FE Echoes.
+This update was made 4/10/2019 with canary Nightly build 1243.
+
CPU underclocking in citras system settings improves some games performance, but crashes Echoes after causing audio problems. (Still happening as of October 2020). Because this is a popular performance increase for most games, make sure to NOT do so for echoes. If you still experience crashing at 100% CPU speed, then overclock it a little.
+ The below game article is based on user submitted content.
+ See a mistake? Want to contribute?
+ Edit this game article on Github
+
+
+
+
+
Fire Emblem Fates: Birthright
+
+
+
+
+
+
+
+
+
+
Rating
+
Bad Game functions, but with major graphical or audio glitches. Unable to progress in specific areas due to glitches even with workarounds.
+
+
+
Type
+
+
+
+
+
+
Game Icon
+
+
+
+
+
+
Title IDs
+
+
+
0004000000179400
+
+
+
+
+
System Files Required?
+
N/A
+
+
+
Shared Font Required?
+
N/A
+
+
+
+
+
+
+
+
+
Fire Emblem Fates has no problem besides the lag spike for 1 second when going to 3d mode besides that there is really nothing broken about it.
+
Edit: The above isn’t entirely true. There is a reproducible crash that can be consistently triggered by watching Corrin and Azura’s S-Support conversations for the Hoshido and Vallite variations of the S-Support. Nohr’s conversation doesn’t have this problem.
+
+
+
+
+
+
+
Compatibility
+
+
+
+
ID
+
Build Date
+
Tested By
+
Hardware
+
Citra Version
+
Rating
+
+
+
+
+
+
+
05b9e012-afbc-49d1-87ac-e9ab15c40321
+
01/9/2022
+
on 01/10/2022
+
AMD Ryzen 5 3500U with Radeon Vega Mobile Gfx AMD Radeon(TM) Vega 8 Graphics Windows
+
Nightly Build 67f1e41
+
Bad
+
+
+
+
32a9e9fc-3e54-4a8e-b883-4dead2c2326f
+
03/11/2021
+
on 09/13/2021
+
Intel(R) Core(TM) i3-3240 CPU @ 3.40GHz Intel(R) HD Graphics 2500 Windows
+
Canary Build 7a60d46
+
Intro/Menu
+
+
+
+
32e09f48-29aa-41f7-8855-bbd664a728fc
+
03/13/2020
+
on 07/21/2020
+
Intel(R) Core(TM) i5-8400 CPU @ 2.80GHz Intel(R) UHD Graphics 630 Windows
+
Canary Build 16eb879
+
Perfect
+
+
+
+
367802a0-d3af-46ff-868b-7a8987f2b50c
+
03/21/2020
+
on 03/21/2020
+
Intel(R) Core(TM) i5-8265U CPU @ 1.60GHz GeForce MX130/PCIe/SSE2 Windows
+
Canary Build 330ca63
+
Great
+
+
+
+
a7552588-f69e-4c7a-b498-552595bbd8d7
+
03/12/2020
+
on 03/15/2020
+
AMD Ryzen 5 3400G with Radeon Vega Graphics AMD 15D8:C8 Windows
+
Nightly Build ad3c464
+
Bad
+
+
+
+
cc555900-635b-4af5-b720-1a4e2fa28529
+
04/19/2020
+
on 04/19/2020
+
Intel(R) Core(TM) i3-4130 CPU @ 3.40GHz AMD Radeon (TM) RX 460 Graphics (POLARIS11, DRM 3.36.0, 5.6.3-2-MANJARO, LLVM 9.0.0) Linux
+
Nightly Build ca722f1
+
Okay
+
+
+
+
cee3e2b5-d7e0-4952-a742-eb2e91ad44f1
+
04/14/2020
+
on 04/15/2020
+
Intel(R) Core(TM) i5-6400 CPU @ 2.70GHz GeForce GTX 750 Ti/PCIe/SSE2 Windows
+
Canary Build f89266a
+
Great
+
+
+
+
d53bfe67-9c6e-49e6-b6fa-4b0f29542352
+
12/9/2020
+
on 12/29/2020
+
Intel(R) Core(TM) i5-10300H CPU @ 2.50GHz GeForce GTX 1650/PCIe/SSE2 Windows
+
Canary Build 6385727
+
Perfect
+
+
+
+
fc583997-76fb-4e80-a64e-40c5335eb332
+
08/1/2021
+
on 08/22/2021
+
AMD Ryzen 7 3700U with Radeon Vega Mobile Gfx AMD Radeon(TM) RX Vega 10 Graphics Windows
+
Nightly Build dfd7926
+
Perfect
+
+
+
+
ff404d6d-1a39-45bc-bd29-20ef691cce7a
+
05/29/2020
+
on 05/30/2020
+
Intel(R) Core(TM) i3-2120 CPU @ 3.30GHz AMD Radeon HD 7000 series Windows
+ The below game article is based on user submitted content.
+ See a mistake? Want to contribute?
+ Edit this game article on Github
+
+
+
+
+
Fluidity: Spin Cycle
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Rating
+
Bad Game functions, but with major graphical or audio glitches. Unable to progress in specific areas due to glitches even with workarounds.
+
+
+
Type
+
+
+
+
+
+
Game Icon
+
+
+
+
+
+
+
+
Title IDs
+
+
+
00040000000AE000
+
+
+
+
+
System Files Required?
+
N/A
+
+
+
Shared Font Required?
+
N/A
+
+
+
+
+
+
+
+
+
Summary
+
Fluidity Spin Cycle has some minor audio issues in Citra, but these do not hinder gameplay. The controls are gyro-based, however the game is still fully playable.
+ The below game article is based on user submitted content.
+ See a mistake? Want to contribute?
+ Edit this game article on Github
+
+
+
+
+
HarmoKnight
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Rating
+
Okay Game functions with major graphical or audio glitches, but game is playable from start to finish with workarounds.
+
+
+
Type
+
+
+
+
+
+
Game Icon
+
+
+
+
+
+
+
+
Title IDs
+
+
+
00040000000C2D00
+
+
+
+
+
System Files Required?
+
N/A
+
+
+
Shared Font Required?
+
N/A
+
+
+
+
+
+
+
+
+
Summary
+
HarmoKnight runs well in Citra on even lower end hardware. Graphically, the game doesn’t have any apparent issues. No problems are known for this game.
+
+
+
+
+
+
+
Compatibility
+
+
+
+
ID
+
Build Date
+
Tested By
+
Hardware
+
Citra Version
+
Rating
+
+
+
+
+
+
+
12889fb0-0c7e-4436-9be2-fe42bd1f2f2a
+
10/5/2019
+
on 10/09/2019
+
AMD FX(tm)-8320 Eight-Core Processor GeForce GTX 1060 6GB/PCIe/SSE2 Windows
+ The below game article is based on user submitted content.
+ See a mistake? Want to contribute?
+ Edit this game article on Github
+
+
+
+
+
Harvest Moon 3D: A New Beginning
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Rating
+
Okay Game functions with major graphical or audio glitches, but game is playable from start to finish with workarounds.
+
+
+
Type
+
+
+
+
+
+
Game Icon
+
+
+
+
+
+
+
+
Title IDs
+
+
+
00040000000A5900
+
+
+
+
+
System Files Required?
+
N/A
+
+
+
Shared Font Required?
+
N/A
+
+
+
+
+
+
+
+
+
## Summary
+Harvest Moon 3D: A New Beginning does not appear to have any graphical issues. Audio seems fine aside from some stuttering. The game runs near full speed with mid tier hardware.
+ The below game article is based on user submitted content.
+ See a mistake? Want to contribute?
+ Edit this game article on Github
+
+
+
+
+
Harvest Moon 3D: The Tale of Two Towns
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Rating
+
Bad Game functions, but with major graphical or audio glitches. Unable to progress in specific areas due to glitches even with workarounds.
+
+
+
Type
+
+
+
+
+
+
Game Icon
+
+
+
+
+
+
+
+
Title IDs
+
+
+
0004000000047900
+
+
+
+
+
System Files Required?
+
N/A
+
+
+
Shared Font Required?
+
N/A
+
+
+
+
+
+
+
+
+
Summary
+
Harvest Moon 3D: The Tale of Two Towns works well, with no major audio or visual issues. Performance on mid-tier hardware is poor during the intro, but near perfect ingame.
+ The below game article is based on user submitted content.
+ See a mistake? Want to contribute?
+ Edit this game article on Github
+
+
+
+
+
Hatsune Miku: Project Mirai DX
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Rating
+
Great Game functions with minor graphical or audio glitches and is playable from start to finish. May require some workarounds.
+
+
+
Type
+
+
+
+
+
+
Game Icon
+
+
+
+
+
+
+
+
Title IDs
+
+
+
0004000000148C00
+
+
+
+
+
System Files Required?
+
N/A
+
+
+
Shared Font Required?
+
N/A
+
+
+
+
+
+
+
+
+
Summary
+
Hatsune Miku: Project Mirai DX has very few problems in Citra. Graphically, the game may or may not suffer from minor issues, but requires mid-range hardware to obtain near full speed. It suffers from minor audio issues at times, but this does not hinder gameplay in any way. The button and touchscreen input feedback is delayed but most of the time the game detects the inputs correctly in the rhythm game.
+ The below game article is based on user submitted content.
+ See a mistake? Want to contribute?
+ Edit this game article on Github
+
+
+
+
+
Hyrule Warriors Legends
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Rating
+
Okay Game functions with major graphical or audio glitches, but game is playable from start to finish with workarounds.
+
+
+
Type
+
+
+
+
+
+
Game Icon
+
+
+
+
+
+
+
+
Title IDs
+
+
+
000400000017EA00
+
+
+
+
+
System Files Required?
+
N/A
+
+
+
Shared Font Required?
+
N/A
+
+
+
+
+
+
+
+
+
Summary
+
Hyrule Warriors Legends works well, though not perfectly on Citra. The game suffers from minor graphical glitches (improper layering of certain sprites with horizon objects), and may require powerful hardware. No current crashes or irresolvable conflicts are known.
+
+
+
+
+
+
+
Compatibility
+
+
+
+
ID
+
Build Date
+
Tested By
+
Hardware
+
Citra Version
+
Rating
+
+
+
+
+
+
+
0f7fe798-9e5b-4497-9702-0a0a0b7012ac
+
07/14/2020
+
on 07/21/2020
+
Intel(R) Core(TM) i7-3770K CPU @ 3.50GHz GeForce GTX 770/PCIe/SSE2 Windows
+
Canary Build d3e12d2
+
Great
+
+
+
+
0fcc8ba6-929c-49af-b2c9-a57c949e4847
+
03/12/2020
+
on 03/13/2020
+
Intel(R) Core(TM) i7-7700HQ CPU @ 2.80GHz Radeon RX 580 Series Windows
+
Nightly Build ad3c464
+
Bad
+
+
+
+
1ec6db71-e006-449d-b22b-32f7ba7e5f33
+
08/7/2020
+
on 08/24/2020
+
Intel(R) Pentium(R) CPU G3260 @ 3.30GHz Intel(R) HD Graphics Windows
+
Nightly Build f72be7a
+
Bad
+
+
+
+
43180b83-f57f-478b-a2f1-b30822c53a5a
+
03/12/2020
+
on 03/12/2020
+
Intel(R) Core(TM) i3-6100U CPU @ 2.30GHz Intel(R) HD Graphics 520 Windows
+ The below game article is based on user submitted content.
+ See a mistake? Want to contribute?
+ Edit this game article on Github
+
+
+
+
+
I Love My Pony
+
+
+
+
+
+
+
+
+
+
Rating
+
Not Tested The game has not yet been tested.
+
+
+
Type
+
+
+
+
+
+
Game Icon
+
+
+
+
+
+
Title IDs
+
+
+
0004000000178C00
+
+
+
+
+
System Files Required?
+
N/A
+
+
+
Shared Font Required?
+
N/A
+
+
+
+
+
+
+
+
+
Summary
+
I Love My Pony runs especially slow. Loading times are fast and you can see the game reach 40-50 FPS in loading, but during the game, the maximum you can get is usually around 9-10 FPS. It also suffers from audio issues. The audio, when the NPCs talk sounds like chirping. As far as I can tell there are no graphical issues.
+ The below game article is based on user submitted content.
+ See a mistake? Want to contribute?
+ Edit this game article on Github
+
+
+
+
+
INAZUMA ELEVEN
+
+
+
+
+
+
+
+
+
+
Rating
+
Bad Game functions, but with major graphical or audio glitches. Unable to progress in specific areas due to glitches even with workarounds.
+
+
+
Type
+
+
+
+
+
+
Game Icon
+
+
+
+
+
+
Title IDs
+
+
+
0004000000112B00
+
+
+
+
+
System Files Required?
+
N/A
+
+
+
Shared Font Required?
+
N/A
+
+
+
+
+
+
+
+
+
Inazuma Eleven in Citra has a bad sound in cinematics and in the page of when you win a pachanga or a match. The game has, in some moments, lowering of fps in the same moments as the problem of sound.
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+ 
+ 
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+
+ 
+
+ 
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+ 
+
+ 
+
+ 
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+
+
+ 
+
+ 
+
+ 
+
+ 
+
+
+
+ 
+
+
+
+ 
+
+ 
+
+ 
+
+ 
+ 
+ 
+
+ 
+
+ 
+
+ 
+
+
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+ 
+ 
+
+ 
+
+ 
+ 
+ 
+ 
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+ 
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+ 
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+ 
+ 
+
+
+
+
+
+
+
+
+ 
+ 
+
+
+
+
+
+
+
+
+ 
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+ 
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+ 
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+ 
+ 
+ 
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+ 
+ 
+ 
+ 
+
+ 
+
+ 
+ 
+ 
+
+ 
+
+ 
+
+ 
+ 
+ 
+
+ 
+ 
+ 
+
+ 
+ 
+ 
+ 
+ 
+
+ 
+
+ 
+
+ 
+ 
+ 
+
+ 
+
+ 
+
+
+
+
+
+
+
+
+ 
+ 
+
+ 
+
+ 
+ 
+ 
+ 
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+ 
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+ 
+
+
+
+
+
+ 
+
+ 
+
+ 
+
+
+ 
+
+
+ 
+ 
00040000000C1400
+ 
+
+ 
+ 
+ 
+ 
+ 
+
+ 
+ 
+ 
+ 
+ 
+
+ 
+ 
+ 
+ 
+ 
+ 
+
+ 
+ 
+ 
+ 
+ 
+ 
+
+ 
+ 
+ 
01006C40086EA000
+ 
+
+ 
+ 
+ 
+ 
+ 
+
+ 
+ 
+ 
+ 
+ 
+
+ 
+ 
+ 
+ 
+ 
+
+ 
+ 
+ 
+ 
+ 
+
+ 
+ 
+
+ 
+ 
+ 
+ 
+ 
+
+ 
+ 
+
+ 
+ 
+ 
+ 
+ 
+
+ 
+ 
+ 
+ 
+ 
+ 
+
+ 
+ 
+ 
+ 
+ 
+
+ 
+ 
+ 
+ 
+ 
+
+ 
+ 
+
+ 
+ 
+ 
+ 
+ 
+
+ 
+ 
+
+ 
+ 
+ 
+ 
+ 
+ 
+
+ 
+ 
+
+ 
+ 
+ 
+ 
+ 
+
+ 
+ 
+ 
+ 
+ 
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+
+ 
+ 
+ 
+
+ 
+ 
+ 
+ 
+ 
+
+ 
+ 
+ 
+ 
+ 
+
+ 
+ 
+ 
+ 
+ 
+ 
+
+ 
+ 
+ 
+ 
+ 
+ 
+
+ 
+ 
+
+ 
+ 
+ 
+ 
+ 
+ 
+
+ 
+ 
+ 
+ 
+ 
+
+ 
+ 
+ 
+ 
+ 
+
+ 
+ 
+ 
+ 
+ 
+
+ 
+ 
+ 
+
+ 
+ 
+ 
+ 
+ 
+
+ 
+ 
+ 
+
+ 
+ 
+ 
+ 
+ 
+
+ 
+ 
+ 
+ 
+ 
+
+ 
+ 
+ 
+ 
+ 
+ 
+
+ 
+ 
+ 
+
+ 
+ 
+ 
+ 
+ 
+ 
+
+ 
+ 
+ 
+
+ 
+ 
+ 
+
+ 
+ 
+ 
+ 
+ 
+
+ 
+ 
+
+ 
+ 
+ 
+
+ 
+ 
+ 
+
+ 
+ 
+ 
+ 
+ 
+
+ 
+ 
+ 
+ 
+ 
+
+ 
+ 
+ 
+
+ 
+ 
+ 
+ 
+ 
+
+ 
+ 
+ 
+ 
+ 
+
+ 
+ 
+
+ 
+ 
+ 
+ 
+ 
+
+ 
+ 
+ 
+ 
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+