repowiserepowise

zortos293 / lichii Architecture and code health

VERY experimental Nintendo Switch 2 emulator

★ 9,661stars on GitHubC++GPL-3.0

Claude Code, Cursor, Codex or VS Code. No key. You approve one sign-in in your browser.

Setup instructions on GitHub

Releases on GitHub (latest build-366, Nov 20, 2026)

Repowise maps public repos from their source. Not affiliated with zortos293. What is Repowise?

github.com/zortos293/lichiiIndexed at dc386a2

What is lichii?

lichii is an experimental, open-source emulator for the Nintendo Switch and Switch 2, written in C++. It is meant for players who run games they have legally obtained. It runs a game's code in software on a desktop or Android device, emulating the console's hardware so the game can run without the original machine. Its code health is 7.5 out of 10 (Good), ranked #99 of 4,000+ indexed repos. The last commit to lichii was on Nov 18, 2026, and 192 people have contributed.

As of commit dc386a2, indexed Nov 18, 2026. What it is comes from a model reading the README; the rest is measured from the source and git history, not from the maintainer.

For agentslichii.md

Repo facts: type, license, health, rank, contributors
lichii facts
LicenseGPL-3.0
Code health7.5 / 10 (Good)
Health rank#99 of 4,000+ indexed repos
Last commitNov 18, 2026
Contributors192
Bus factor2
Size4,271 files, 824,349 lines

Explore lichii

Ask about this code in your agent

This connects Repowise to lichii's code. It does not install lichii.

Useful if you want to change or fork lichii: your agent can ask how it is put together and get answers that cite its files.

Ask about lichii

Answers come from lichii's README and source, with the files they cite. Two free answers a day without an account.

Featured answer

lichii is a very experimental, open-source emulator for the Nintendo Switch and Switch 2, written in C++, and it is meant for running games the user has legally obtained. It emulates the console's hardware in software on a desktop or Android device so games can run without the original machine. Input enters through the desktop front end or the Android app, where EmulationActivity.kt starts a game and NativeLibrary loads the native library and forwards calls over JNI to the C++ code. src/core opens the game's files, sets up the emulated machine and runs the guest CPUs, and most of its files implement the kernel and service emulation that system calls reach, while src/audio_core handles audio and src/video_core, including renderer_vulkan/vk_rasterizer.cpp, handles Vulkan graphics, with src/common supplying shared headers for basic types, assertions and logging. The layer chart shows Application with 1970 files, Service with 1230 and Utility with 465, so start reading with src/core and the Android entry point EmulationActivity.kt.

Files per layer in lichii8 layers.

Basis: Inferred · knowledge graph· as of dc386a2

Want this for your own codebase? Map your repo free

About this page

Get a page like this for your own codebase

Repowise built this map of zortos293/lichii from its source and git history. It parses every symbol, draws the dependency graph, scores each file's health from complexity, duplication, coverage and churn, finds hotspots and owners in the history, and writes documentation for every module. Your coding agent reads the same index over MCP, so its answers cite real files.

Free for 2 public repos, with a page like this one. No card. See how Repowise works

Prefer local? pip install repowise && repowise init indexes your own checkout, no account needed. Star Repowise on GitHub

zortos293/lichii FAQ

What is lichii?

lichii is an experimental, open-source Nintendo Switch and Switch 2 emulator written in C++. It is for players who run games they have legally obtained. It is not affiliated with Nintendo.

How does lichii work?

lichii emulates the console in software. The src/core directory opens a game's files, sets up the emulated machine and runs the guest CPUs. Desktop and Android front ends send input to it, and the Android app reaches the C++ code over JNI.

What language is lichii written in?

lichii is written mainly in C++. Its Android app is written in Kotlin, and its build and CI scripts are written in shell and Python.

How is the lichii code organized?

The main code is in src, with src/core for running games, src/audio_core for audio and src/common for shared utilities. src/android holds the Android app, tools holds developer tools, and .ci holds scripts that build the Android app and check license headers.

Who is lichii for?

lichii is for players who run games they have legally obtained, such as homebrew they have permission to run or dumps from a console they own. It is an experimental project, so downloads should come only from its releases page.

What license does lichii use?

lichii is licensed under GPL-3.0.

Code health

7.4out of 10Good

Hotspots average 5.3, the place fixes pay off most.

On the leaderboards:#3 of 12 C++ repos

Key features of lichii

  • Emulates Nintendo Switch and Switch 2 games in software on desktop and Android.
  • Links to a game compatibility website where players can find games and compare community compatibility reports.
  • Lets players submit a compatibility report for a Switch 2 game in builds that include that feature, after previewing the report and giving explicit consent.
  • Offers to import saves and settings from Eden and other detected emulator profiles on the first non-portable GUI launch.
  • Gives guidance for issue reports, asking for the exact build, hardware and driver versions, settings and steps to reproduce.

How zortos293/lichii works

Input enters through the desktop front end or the Android app, where EmulationActivity.kt starts a game. The Android app's NativeLibrary object loads the native library and forwards calls over JNI to the C++ code. src/core does the core work: it opens the game's files, sets up the emulated machine and runs the guest CPUs until the title stops. Most of its files implement the kernel and service emulation that a game's system calls reach. src/audio_core emulates the audio stack, and the Vulkan renderer code under src/video_core, such as renderer_vulkan/vk_rasterizer.cpp, handles graphics. src/common holds the shared headers for basic types, assertions and logging that the rest of the emulator includes.

The codebase has 4,271 files and 84,553 symbols in 4 modules, led by C++, Kotlin and Python. Code health is 7.4 out of 10, rated good.