Cemu

Cemu - Wii U emulator

8,250

691

8,250

330

View on GitHub

Top Related Projects

dolphin

13,959

Dolphin is a GameCube / Wii emulator, allowing you to play games for these two platforms on PC with improvements.

rpcs3

17,242

PlayStation 3 emulator and debugger

Ryujinx

34,468

Experimental Nintendo Switch Emulator written in C#

pcsx2

13,304

PCSX2 - The Playstation 2 Emulator

Quick Overview

Cemu is an experimental software emulator for the Nintendo Wii U console. It allows users to play Wii U games on PC with high compatibility and performance. Cemu is known for its ability to enhance graphics beyond the original console's capabilities.

Pros

High compatibility with a large number of Wii U games
Ability to run games at higher resolutions and frame rates than the original console
Active development and frequent updates
Supports various input methods, including keyboard/mouse and various controllers

Cons

Requires relatively powerful hardware for optimal performance
Some games may have minor graphical glitches or compatibility issues
Legal concerns regarding game ROM acquisition
Limited documentation for setup and troubleshooting

Getting Started

Download the latest version of Cemu from the official website or GitHub releases.
Extract the downloaded archive to a folder of your choice.
Run Cemu.exe to start the emulator.
Go to Options > General Settings to configure your preferred settings.
To add games, go to File > Install game title, update or DLC and select your game files.
Configure controller inputs in Options > Input settings.
Load a game by double-clicking it in the game list or using File > Load.

Note: Ensure you have the necessary game files and that you comply with copyright laws in your region when using Cemu.

Competitor Comparisons

dolphin

13,959

Dolphin is a GameCube / Wii emulator, allowing you to play games for these two platforms on PC with improvements.

Pros of Dolphin

Supports a wider range of systems (GameCube and Wii)
Open-source with a larger community of contributors
More mature project with longer development history

Cons of Dolphin

May require more powerful hardware for optimal performance
Less focus on high-resolution graphics enhancements
Potentially more complex setup for casual users

Code Comparison

Dolphin (C++):

void DSP::Step()
{
  const u64 cycles = static_cast<u64>(m_cycles_left);
  m_cycles_left -= cycles;
  m_core->Step(cycles);
}

Cemu (C++):

void DSPCore::step()
{
    if (m_state == DSPState::Running)
        m_dsp->step();
}

Both emulators use C++ and implement similar stepping functions for their respective DSP (Digital Signal Processor) emulation. Dolphin's implementation appears to handle cycle counting more explicitly, while Cemu's approach is more straightforward but potentially less precise in terms of timing.

rpcs3

17,242

PlayStation 3 emulator and debugger

Pros of RPCS3

Open-source and community-driven development
Supports a wider range of PlayStation 3 games
More active development with frequent updates

Cons of RPCS3

Generally requires more powerful hardware for optimal performance
Can be more complex to set up and configure for some users

Code Comparison

RPCS3 (C++):

void RSXThread::flip(u32 buffer, bool emu_flip)
{
    if (emu_flip)
    {
        // Perform emulator-specific flip operations
    }
    // ... (additional code)
}

Cemu (C++):

void Renderer::SwapBuffers()
{
    // Perform buffer swapping operations
    // ... (additional code)
}

Both emulators use C++ for their core functionality, but RPCS3's codebase tends to be more complex due to the intricacies of PS3 emulation. Cemu's code is often more straightforward, focusing on Wii U-specific features. RPCS3's open-source nature allows for more community contributions and transparency in development, while Cemu's closed-source approach may lead to more optimized code for specific Wii U functions.

Ryujinx

34,468

Experimental Nintendo Switch Emulator written in C#

Pros of Ryujinx

Better accuracy in emulating Nintendo Switch games
Supports a wider range of Switch titles
More active development and frequent updates

Cons of Ryujinx

Generally lower performance compared to Cemu
Requires more powerful hardware to run smoothly
Less mature and polished user interface

Code Comparison

Ryujinx (C#):

public void Initialize(Switch device)
{
    _device = device;
    _gpu = device.Gpu;
    _context = _gpu.CreateSharedContext();
}

Cemu (C++):

void GX2Init(u32 initAttribs)
{
    gx2State.initAttribs = initAttribs;
    gx2State.initialized = true;
    gx2State.mainCoreIndex = OSGetCoreId();
}

The code snippets show initialization processes for both emulators. Ryujinx uses C# and focuses on device and GPU setup, while Cemu uses C++ and initializes the GX2 graphics API. This reflects the different approaches and architectures of the two projects.

xenia

8,794

Xbox 360 Emulator Research Project

Pros of Xenia

Supports a wider range of Xbox 360 games
More active development and frequent updates
Better documentation and community support

Cons of Xenia

Generally lower performance compared to Cemu
Less stable and more prone to crashes
Fewer graphical enhancements and customization options

Code Comparison

Xenia (C++):

void GraphicsSystem::Initialize() {
  // Initialize graphics subsystem
  auto provider = GraphicsProvider::Create(provider_type_);
  if (!provider) {
    XELOGE("Unable to initialize graphics provider");
    return;
  }
  provider_ = std::move(provider);
}

Cemu (C++):

void Renderer::Initialize() {
  // Initialize renderer
  if (!gfx_api::InitializeGraphicsAPI()) {
    cemuLog_log(LogType::Force, "Failed to initialize graphics API");
    return;
  }
  m_initialized = true;
}

Both projects use C++ and have similar initialization patterns for their graphics systems. However, Xenia's code appears to be more modular with its use of a provider system, while Cemu's code is more straightforward in its initialization process.

pcsx2

13,304

PCSX2 - The Playstation 2 Emulator

Pros of PCSX2

Supports a wider range of games (PS2 library)
More mature project with longer development history
Extensive compatibility list and community support

Cons of PCSX2

Generally requires more powerful hardware for optimal performance
More complex configuration due to PS2 hardware emulation
Slower development cycle compared to Cemu

Code Comparison

PCSX2 (C++):

void GSState::Flush(GSFlushReason reason)
{
    if(m_dev->IsDeviceLost()) return;
    if(!m_per_frame_flush && reason == GSFlushReason::FLUSH_ONCE_PER_FRAME) return;
    // ... (additional code)
}

Cemu (C++):

void Texture_LoadTextureFromFileSystem(uint32 width, uint32 height, uint32 format, uint8* imageData, sint32 imageSize)
{
    TextureDecoder_DecodeTexture(width, height, format, imageData, imageSize);
    // ... (additional code)
}

Both projects use C++ and focus on hardware emulation, but PCSX2's codebase is generally more complex due to the intricacies of PS2 hardware. Cemu's code tends to be more streamlined, reflecting the relatively simpler architecture of the Wii U.

Convert designs to code with AI

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

README

Cemu - Wii U emulator

This is the code repository of Cemu, a Wii U emulator that is able to run most Wii U games and homebrew in a playable state. It's written in C/C++ and is being actively developed with new features and fixes.

Cemu is currently only available for 64-bit Windows, Linux & macOS devices.

Links:

Other relevant repositories:

Download

You can download the latest Cemu releases for Windows, Linux and Mac from the GitHub Releases. For Linux you can also find Cemu on flathub.

On Windows Cemu is currently only available in a portable format so no installation is required besides extracting it in a safe place.

The native macOS build is currently purely experimental and should not be considered stable or ready for issue-free gameplay. There are also known issues with degraded performance due to the use of MoltenVK and Rosetta for ARM Macs. We appreciate your patience while we improve Cemu for macOS.

Pre-2.0 releases can be found on Cemu's changelog page.

Build Instructions

To compile Cemu yourself on Windows, Linux or macOS, view BUILD.md.

Issues

Issues with the emulator should be filed using GitHub Issues.
The old bug tracker can be found at bugs.cemu.info and still contains relevant issues and feature suggestions.

Contributing

Pull requests are very welcome. For easier coordination you can visit the developer discussion channel on Discord or alternatively the Matrix Server. Before submitting a pull request, please read and follow our code style guidelines listed in CODING_STYLE.md.

If coding isn't your thing, testing games and making detailed bug reports or updating the (usually outdated) compatibility wiki is also appreciated!

Questions about Cemu's software architecture can also be answered on Discord (or through the Matrix bridge).

License

Cemu is licensed under Mozilla Public License 2.0. Exempt from this are all files in the dependencies directory for which the licenses of the original code apply as well as some individual files in the src folder, as specified in those file headers respectively.

Top Related Projects

Convert designs to code with AI

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot