Monado

#ESPAÑOL

Rendimiento e interfaz V6

Se añadieron perfiles Equilibrado/Rendimiento/Patata, objetivos FPS independientes, optimizaciones internas y una interfaz grafito/verde. Los recortes decorativos nuevos son opcionales y experimentales. Uso, configuración, compilación y límites en Rendimiento e interfaz; resultados y pruebas pendientes en evidencia local. No se promete una ganancia de FPS sin medición por escena/equipo.

Continuación técnica local — 2026-11-04

Se añadieron selección de GPU por nombre, negociación Vulkan 1.2/1.3, correcciones de reutilización de imágenes y memoria no coherente, temporización fraccionaria y pruebas sin datos del juego. El estado comprobado y los problemas que siguen abiertos están en validación del port. No es una nueva release ni una certificación de compatibilidad jugable.

Ampliación: selector de rutas Vulkan 1.2/1.3/1.4, DLSS automático con runtime oficial y contador FPS en pantalla.

ATENCION

Se está encontrando la solución al crash de AMD y los bajones de fps. (resulta que son ciertos shaders pesados que hacen que falle) el proyecto original ya ofrecía una opción para omitir esos shaders aunque se necesita tiempo y testing para probar todos los shaders que causan problemas y omitirlos (el lag principal está resuelto). La actualización v5 se publicará con estas mejoras y ya seré feliz xd.

Si tienen algun error favor de ponerlo en la pestaña ISSUES para ver si se puede corregir.

Inicio

Hola esta versión se modifico gracias a Claudio (el trabajo original ya esta hecho casi en su totalidad por una IA pero le e puesto mejoras y solucionado errores.

Se basa en el fork: https://github.com/vinitaison/Monado Que a su vez se basa en el original de TheMonadoGuy/Monado (Ya lo tumbaron pero recordaremos tu sacrificio)

---

AVISO:

Para poder usarlo hay que instalar GIT (se supone si lo quieres construir tu sino puedes descargar el PORTABLE y creo que no depende de GIT no lo e testeado).

Tener 7zip instalado (Para descomprimir): https://www.7-zip.org/

GIT: https://git-scm.com/install/windows

Seleccionar y instalar: Standalone Installer Git for Windows/x64 Setup.

NO SE UTILIZA LOS ARCHIVOS NSP NI NADA DE ESO EN CAMBIO SE UTILIZAN LOS DATOS DE TU JUEGO EXTRAIDO (ya sea de una switch original con tu copia legal del juego con la actualización 2.0.0 aplicada) ESTO SE PUEDE HACER CON RYUJINX YA QUE PERMITE EXTRAER TU COPIA LEGALMENTE.

---

NOTA:

Si descargas la versión portable pon tu Exefs y Romfs en la carpeta /targets recuerden que debe ser de la version 2.0.0.

1.- La versión de COMPILAR.zip (necesita COMPILAR) esta tiene todo vacío así que en esta tendrás que descargar las librerías (se descargan solas) y instalar GIT es muy importante sino no iniciara. GIT: https://git-scm.com/install/windows

Pasos:

1.- Tienen que iniciar el Build Monado.bat lo que hará será instalar todas las dependencias necesarias 5Gb aproximadamente.

2.- Dentro del .bat les dirán que seleccionen el juego ya extraído su Romfs y su Exefs.

3.- Una ves terminado el progreso y ya compilado lo pueden iniciar.

4.- Iniciar Play Monado

5.- Esperan a que inicie y compile los shaders para que no haya lag.

---

2.- LA MEJOR VERSION VAMOSSS!!! es Xde-Portable.zip (SIN COMPILAR NADA ES DIRECTO) Esta versión ya esta COMPILADA desde mi pc y hecha para poner en hasta una USB no necesitan nada instalado.

NOTA: NECESITAS IGUALMENTE TUS EXEFS Y ROMFS.

Pasos:

1.- Copiar tus Exefs y Romfs extraídos en la carpeta /targets/Romfs y /targets/Exefs dentro del port.

2.- Inicia el juego y espera a que compilen los shaders y listo xd.

---

Gracias por leerlo se que da hueva pero que se le hará xd. Este fork lo hice yo Ivan Prestef2 estuve testeando y probándolo espero que lo disfrutes también visita mi canal de YouTube para ver mis videos xd.

---

#INGLES

V6 Performance and Interface

Balanced/Performance/Potato profiles, independent target FPS, internal optimizations, and a graphite/green interface were added. The new decorative cutouts are optional and experimental. Usage, configuration, compilation, and limits are in Performance and UI; results and pending tests are in local evidence. No FPS gain is promised without per-scene/per-rig measurement.

Local Technical Continuation — 2026-11-04

GPU selection by name, Vulkan 1.2/1.3 negotiation, image reuse and non-coherent memory fixes, fractional timing, and tests without game data were added. Verified status and remaining open issues are in port validation. This is neither a new release nor a playable compatibility certification.

Expansion: Vulkan 1.2/1.3/1.4 path selector, automatic DLSS with official runtime, and on-screen FPS counter.

ATTENTION

A solution for the AMD crash and FPS drops is being found (it turns out certain heavy shaders are causing it to fail). The original project already offered an option to skip those shaders, though it takes time and testing to try all the problematic shaders and skip them (the main lag is resolved). The v5 update will be published with these improvements and I'll be happy lol.

If you encounter any error, please post it in the ISSUES tab to see if it can be fixed.

Start

Hello, this version was modified thanks to Claudio (the original work is almost entirely done by an AI, but I've added improvements and fixed bugs).

It is based on the fork: https://github.com/vinitaison/Monado Which in turn is based on the original by TheMonadoGuy/Monado (It's already down, but we will remember your sacrifice)

---

NOTICE:

To use it, you need to install GIT (supposedly if you want to build it yourself, otherwise you can download the PORTABLE one and I think it doesn't depend on GIT, I haven't tested it).

Have 7zip installed (To unzip): https://www.7-zip.org/

GIT: https://git-scm.com/install/windows

Select and install: Standalone Installer Git for Windows/x64 Setup.

NSP FILES OR ANYTHING LIKE THAT ARE NOT USED; INSTEAD, YOUR EXTRACTED GAME DATA IS USED (either from an original Switch with your legal copy of the game with update 2.0.0 applied). THIS CAN BE DONE WITH RYUJINX AS IT ALLOWS YOU TO EXTRACT YOUR COPY LEGALLY.

---

NOTE:

If you download the portable version, put your Exefs and Romfs in the /targets folder; remember it must be version 2.0.0.

1.- The COMPILAR.zip version (needs COMPILING) comes completely empty, so in this one you will have to download the libraries (they download automatically) and install GIT. It is very important, otherwise it won't start. GIT: https://git-scm.com/install/windows

Steps:

1.- You have to run Build Monado.bat, which will install all necessary dependencies—approximately 5GB.

2.- Inside the .bat it will tell you to select your already extracted game Romfs and Exefs.

3.- Once the progress is finished and it's compiled, you can start it.

4.- Start Play Monado

5.- Wait for it to start and compile the shaders so there is no lag.

---

2.- THE BEST VERSION LET'S GOOO!!! is Xde-Portable.zip (NO COMPILING NEEDED, IT'S DIRECT) This version is already COMPILED from my PC and made to fit even on a USB stick; you don't need anything installed.

NOTE: YOU STILL NEED YOUR EXEFS AND ROMFS.

Steps:

1.- Copy your extracted Exefs and Romfs into the /targets/Romfs and /targets/Exefs folders inside the port.

2.- Start the game, wait for the shaders to compile, and that's it lol.

---

Thanks for reading, I know it's a pain, but what can you do lol. I made this fork, I'm Ivan Prestef2, I was testing and trying it out. I hope you enjoy it as well; also visit my YouTube channel to watch my videos lol.

---

Proyecto ORIGINAL

Monado

Monado is a static recompilation of Xenoblade Chronicles: Definitive Edition (Nintendo Switch, 2020) into a native Windows x86-64 application with a Vulkan renderer. It is not an emulator: the game's ARM64 code is translated ahead of time into C and compiled for your PC, and the console's operating system and graphics API (NVN) are reimplemented on top of Windows and Vulkan.

It is built on LASRecomp (MIT), the static recompilation of Link's Awakening, whose generator and runtime it adapts. Internally the project still uses its working name XCDE (build/xcde.exe, XCDE_* environment variables, [XCDE] marks in the code).

Status

The whole game is playable on Windows with an NVIDIA RTX GPU: the story, battles, side quests, Heart-to-Hearts, Future Connected, menus, cutscenes and videos with audio. The original developer considers it finished for their own PC and is looking for someone to continue it, above all on AMD, Intel and lower-end hardware, which are largely untested. See Known issues and Where the knowledge is.

Features

Graphics

• Internal resolution: match the window (default), 1x–3x the Switch's image (up to 4K), 75 % / 50 % of the window, or dynamic resolution that follows performance. Ultrawide windows keep their shape.
• Upscaling and anti-aliasing:
  • spatial: AMD FSR 1.0;
  • temporal: AMD FSR 3.1 or NVIDIA DLSS (with native-AA / DLAA modes);
  • extra: SMAA.
• FSR 3 frame generation, everywhere or only in cutscenes (an even 60 on screen for scenes the game animates at 30).
• Toggles for the game's own depth of field, temporal AA and motion blur (tuned for the Switch's 720p).

Frame rate

• 30 / 60 / 120 / 144 / 165 / unlimited without changing the speed of the world, the clock or cutscenes.
• Optional steady-30 cutscenes and V-Sync.

Controls

• Keyboard and mouse in an MMO-style layout: mouse camera, keys 1–8 + T fire the arts in the palette.
• Every key, mouse button and controller button can be remapped.
• Button prompts drawn from your own key bindings. Xbox / PlayStation icon packs (third-party, from GameBanana, not included) are picked by the connected controller.
• Configurable stick dead zone for controllers with drift.
• Xenoblade 3-style party switching (hold L2, press L1 / R1) in the field and in battle.

Robustness

• Shader precompilation: a seed of ~30,000 pipeline variants built ahead of time, so the first visit to an area doesn't stop to compile. The SPIR-V cache is a single file (cache/spirv.pack).
• Safe saves: the game's save commits are honoured with a journal, so a crash in the middle of a save rolls back to the last good one. Every session keeps an automatic backup (save/backup/, the newest 5).
• Diagnostics: crash reports with minidumps, a hang watchdog, and a launcher button that zips the logs for a bug report.
• Low-end aware: RAM size, integrated GPUs and core count are detected, and caches, budgets and thread counts are scaled to them. The target is a Ryzen 3 3200G (Vega 8) with 8 GB at 720p.

Launcher and mods

• A launcher (English / Spanish) for every setting, the shader precompilation and the bug report.
• Mods: romfs mods in mods/<name>/romfs/ (the same layout as Ryujinx / yuzu). Code mods (exefs, IPS / pchtxt) don't apply to a recompilation.

Requirements

• OS: Windows 10 / 11, x86-64 (x86-64-v2: SSE4.2, no AVX needed).
• GPU: Vulkan 1.3.
  • Tested: NVIDIA RTX.
  • Not verified on real hardware: AMD and Intel (including iGPUs). Fixes are in place, but reports are welcome.
• RAM: 8 GB minimum (tight), 16 GB recommended. The game's own heap is 3.2 GB; see Known issues.
• Disk: ~15 GB for the game files, ~5 GB for the build, plus caches.
• Your game files: see the next section.

Game files: what and where

You need the game's own files, from your own copy of Xenoblade Chronicles: Definitive Edition. Instructions on how to obtain them are not provided.

Format: plain extracted folders, not packages. An .nsp, .xci or .nca is refused: those are game packages, not game files.

Version: exactly 2.0.0 (title ID 0100ff500e34a000). This means the base game with the 2.0.0 update applied:

• exefs is the update's: its main is the 2.0.0 one;
• romfs is the base romfs with the update's files laid over it.

The base game alone (1.0.0) does not work: the recompiled code is the 2.0.0 main.

Layout: one folder holding both:

<any folder>/
├── exefs/
│   ├── main          (the game; build-id 7e1df8e08d60544b)
│   ├── main.npdm
│   ├── rtld
│   ├── sdk           (build-id ad3fdfbd62a5f4b0)
│   └── subsdk0
└── romfs/            (18,529 files, 13.6 GB)
    ├── bdat/
    ├── chr/
    ├── ...

Where: anywhere on your disk.

• With Build Monado.bat, you pick that folder and it links targets\exefs and targets\romfs to it. Nothing is copied, and the folder you pick may also be a few levels above exefs/romfs.
• By hand, put (or link) them at targets/exefs/ and targets/romfs/ in this repository.

tools/extract/check_dump.py targets verifies them:

• the exefs, by build-id;
• the romfs, against a per-folder manifest of names and sizes.

If it fails, it says which files are missing or different. It reports a wrong version (a 1.0.0 main, for example) separately.

Building

The build runs the recompiler on your machine, from your own game files. It takes 10–20 minutes the first time and ~5 GB of disk. You need Git for Windows (the build scripts run in Git Bash).

The easy way: Build Monado.bat

Run Build Monado.bat from the repository root. It does three things, asking before anything is installed:

1. Tools: if they aren't set up, it runs tools\setup_windows.ps1, which installs MSYS2 with SDL3, FFmpeg, Vulkan, shaderc, VMA and Opus, plus Python 3.12 (via winget), and creates .venv with the recompiler's packages.

2. Your game files: choose the folder that has the game's exefs and romfs folders in it (or a folder above them: they are found up to 4 levels down).

   • .xci / .nsp / .nca packages are refused without being read: the game's own extracted files are needed.
   • The version (2.0.0) and the romfs contents are checked.
   • targets\ is then linked to those folders, so nothing is copied.

   This is tools\setup_game_files.ps1.

3. Build: scripts/build_all.sh checks the files, recompiles the game code, compiles it with the runtime and builds the launcher. The log goes to build\build_all.log.

When it finishes it offers to start the launcher: press Precompile shaders once, then PLAY.

By hand

1. Install the tools (or run powershell -ExecutionPolicy Bypass -File tools\setup_windows.ps1).
   • MSYS2 at C:\msys64. In its UCRT64 shell, install the libraries the runtime links against:

     pacman -S mingw-w64-ucrt-x86_64-sdl3 mingw-w64-ucrt-x86_64-vulkan-devel mingw-w64-ucrt-x86_64-shaderc \
               mingw-w64-ucrt-x86_64-vulkan-memory-allocator mingw-w64-ucrt-x86_64-ffmpeg mingw-w64-ucrt-x86_64-opus
     

   • Python 3.12+ and Git for Windows (the scripts run in Git Bash).
   • A virtual environment in the repository root, with the generator's packages and the Zig toolchain (used as the C compiler):

     python -m venv .venv
     .venv/Scripts/pip install capstone unicorn lz4 ziglang
     

2. Place your game files in targets/exefs/ and targets/romfs/ (or run tools\setup_game_files.ps1), then check them:

   python tools/extract/check_dump.py targets
   

3. Recompile the game code into C (generated/, ~240 MB, never commit it):

   cd tools && ../.venv/Scripts/python -X utf8 gen_all.py --out ../generated && cd ..
   

4. Compile the game objects and the runtime (in Git Bash; scripts/build_all.sh runs steps 2–4 in one go). The boot script also links a window-less dev exe from an old milestone that no longer links; XCDE_SKIP_BOOT_LINK=1 skips it:

   XCDE_SKIP_BOOT_LINK=1 scripts/build_boot.sh   # the recompiled game -> build/obj/
   scripts/build_rt_gfx.sh                       # the runtime + Vulkan renderer -> build/xcde.exe
   tools/launcher/build.sh                       # the launcher -> build/xcde_launcher.exe
   

5. Optional: temporal upscalers. FSR 3.1 and DLSS need vendor DLLs that aren't redistributed here: the AMD FidelityFX SDK 1.1.4 (signed prebuilt DLL) and NVIDIA Streamline 2.14.16. Download them yourself and run SDK_DIR=<folder> scripts/copy_upscaler_dlls.sh, which copies them next to build/xcde.exe. Without them, those options fall back to FSR 1.0.
6. Play: run Play Monado.bat. The first time, press Precompile shaders (a few minutes) and then PLAY.

scripts/ci.sh runs the unit tests (no game data needed); scripts/native_tests.sh the C tests.

Settings

Everything is set in the launcher and saved to xcde.ini in the repository root. Useful keys:

Key	Values
resolution	match, 1–3, 75%, 50%, dynamic
upscaler / upscale_quality	bilinear fsr fsr3 dlss / native quality balanced performance ultra
frame_gen, antialias	0/1, smaa / off
fps, vsync, cutscenes	30 60 120 144 165 unlimited, 0/1, same / 30 / 30fg
depth_of_field, game_blur	0/1
language	auto, en-US, es, fr, de, it, ja (the game's text; only what your copy includes)
stick_deadzone	0–30 (% of the stick's travel; 0 = raw)
`bind_