Dragon Age: Origins — Recompiled

Dragon Age: Origins — Recompiled

A static recompilation of the Xbox 360 version of Dragon Age: Origins into a native x86-64 Windows program, with a Direct3D 12 renderer based on Xenia's. It adds:

• rendering at up to 4K (and higher), with FSR 1 / CAS scaling of the whole image
• temporal upscaling and anti-aliasing with AMD FSR 4 (RDNA 4), FSR 3.1, Intel XeSS-SR or NVIDIA DLSS 4.5 (RTX GPUs, experimental), using motion vectors generated for the game's 3D scenes, which also drive optional motion blur (of the camera, characters and objects), and optional FSR 3.1 frame generation (a frame between each two, for a display at twice the frame rate; only real frames are shown on one that can't keep up)
• neural rendering on AMD RDNA 4 (experimental): lmxxf's open-source port of DLSS 5's neural rendering, built in, with the network's weights from your download of lmxxf's package (they're NVIDIA's, and not included)
• HDR output: on an HDR display the 3D scenes are rendered in HDR (the game's tonemapping redone without compressing its highlights), upscaled in HDR; HDR quality High keeps it 16-bit scRGB all the way to the display
• 60 fps (the original is locked to 30), or up to 240 or unlimited (experimental)
• low latency with AMD Radeon Anti-Lag 2 (AMD GPUs) or NVIDIA Reflex (NVIDIA GPUs, experimental)
• field of view settings: gameplay's, and conversations' (and, it seems, cutscenes') separately
• SDL3 input, including DualSense and other controllers
• a launcher for settings, mods (file overrides, with a converter for PC mods) and code patches
• a Graphics tab in the game's own Options menu (title and pause menus)
• a photo mode (the START menu's Photo Mode row, or L3+R3): a free camera with the world paused, field of view, roll, frames from 32:9 to 9:16 and composition grids, saving PNGs to Pictures\DAORecomp
• a cheats menu (the START menu's Cheats row, Options → Graphics → Open cheats in a game, or F7): the developers' own debug scripts, still in the game, for immortality, skill checks, gold, experience and more
• an on-screen keyboard for naming characters, usable with a gamepad
• the downloadable content (Awakening and the rest), installed from your own packages
• the game's text in English, Italian or Spanish (the languages on the disc; the voices are English in each), chosen in the launcher

This repository contains no game code or data. You need your own copy of the game: an ISO image of the Xbox 360 disc. The installer extracts it, translates the game's code to C++ on your computer, and builds the program.

Installing

You need:

• An x86-64 PC running Windows 10/11 or Linux, with a Direct3D 12 capable GPU and a processor with AVX (most from 2011 or later). The game is built for your processor: with AVX2 (Intel from 2013, AMD from 2015) it uses those newer instructions. A copy built that way and moved to a PC without them says so when it starts; run the installer on that PC to build it for its processor.
• The disc image of Dragon Age: Origins for Xbox 360 (title ID 454108C0): the English, Italian and Spanish edition (media ID 186A1115), which is also disc 1 of that edition's Ultimate Edition. The installer checks that it is the supported release (the French and German editions are other discs, not supported). The game's language is chosen in the launcher (Configure → Advanced → Game language, or language in the [game] section of userdata/config.toml).
• About 25 GB of disk space: 8 GB for the game, the rest for the tools and the build. The first build takes 30–60 minutes, depending on the CPU.

Windows

Download DAORecomp.exe from the releases and run it: it opens on its Install page, drawn like the launcher (with the title screen from your disc once you pick it). Pick the ISO and an install folder, accept the build tools license, and press Install. Nothing else needs to be installed first: it downloads what it needs (including a portable git if you have none). It builds the game into the install folder as a new DAORecomp.exe, which then opens as the launcher: Play starts the game. It can also add Start menu and desktop shortcuts, and add the game to Steam.

The disc image and the folder can be given to it (or the ISO dropped on it):

DAORecomp.exe --iso "D:\Games\Dragon Age Origins.iso" --dest "D:\Games\DAORecomp"

The tools and the build go into %LOCALAPPDATA%\DAORecomp-build (set DAO_WORK_DIR to use another folder). Keep it and a newer installer only rebuilds what changed; delete it to get the space back.

Windows may warn about DAORecomp.exe because it isn't code-signed (More info → Run anyway).

Title updates and downloadable content

Awakening, Leliana's Song, The Darkspawn Chronicles, The Golems of Amgarrak and Witch Hunt need the game's Title Update 6 or 7 (the other DLC work without it; 7, the last, adds fixes to 6's in its data files). To use them, copy the title update's package and the DLC packages from a console (or your backup of them) and:

• give the installer the title update's package: Title Update 6 or 7 (optional) in the window, or --title-update <package>. It is checked (it must be the one for the English, Italian and Spanish disc, media ID 186A1115), extracted to title_update/ in the install folder, and the game's code is translated a second time from the updated executable (about as long again). The program then holds both versions and runs the updated one while title_update/ is there.
• drop the DLC packages, or the folder holding them, on the launcher window. They are extracted to userdata/content/454108C0/00000002/, where the game finds them. A title update dropped there is installed too (7 replaces 6); if the program was built without one, it takes effect after running the installer again on the same folder.

Only packages in the read-only format Xbox Live delivers them in (LIVE/PIRS) are read; the packages themselves are left as they are. At start, title_update/default.xexp is checked to be Title Update 6's or 7's; anything else is passed over for the disc's version. The launcher's Downloadable Content shows which DLC and title update are installed (and whether the game can use them), and packages can be dropped there too.

Linux (or from the source on Windows)

Install Python 3.10+ with Tkinter, git and a C++ standard library (Debian/Ubuntu: sudo apt install build-essential python3-tk git; Fedora: sudo dnf install gcc-c++ python3-tkinter git; Arch: sudo pacman -S base-devel tk git). Then:

git clone <this repository> DAORecomp
cd DAORecomp
python3 install.py

or python3 install.py --iso "/path/to/Dragon Age Origins.iso" --dest ~/Games/DAORecomp. Here the tools and the build go into tools/ and build/ inside the checkout, and after a git pull the installer rebuilds only what changed.

Running the installer again resumes an interrupted install.

Updating

The launcher looks for a newer release when it opens and, if there is one, shows an Update item with the release notes. It downloads the new release's DAORecomp.exe into update/ in the install folder, checks it against the SHA-256 GitHub lists for it, and runs it on the same folder; it rebuilds only what changed (the disc image isn't needed again) and keeps your saves, settings and mods. The checksum catches a damaged or altered download; like the release itself, it comes from this GitHub repository.

There are two update channels, chosen in Configure → Advanced (or with update_channel = "release" or "dev" in [launcher]):

• Release (the default): releases only (vX.Y.Z; while the version is 0.x they're marked pre-release on GitHub, and offered all the same).
• Dev: dev releases too (vX.Y.Z-dev.N): test builds published between releases, for trying what's next early. They can have bugs. An install made from a dev release starts on this channel.

The check asks api.github.com/repos/96dot/Dragon-Age-Origins-Recomp/releases for the list of releases; the request carries only the program's version. Launchers up to v0.10.0-dev.5 don't see releases since the repository was renamed (from DAORecomp): update those by hand once. Turn the check off in Configure → Advanced or with check_updates = false in the [launcher] section of userdata/config.toml. Builds from source (dev, or a changed checkout of a release or dev release) don't check. With the launcher hidden there is no check: open it now and then (hold Shift).

To update by hand, run a newer release's DAORecomp.exe and choose the same install folder (or give it --dest). Under Wine or Proton the launcher only links to the release page: update the checkout (git pull, or check out the new tag) and run python3 install.py --dest <install folder>.

What it downloads

Everything is pinned to exact versions and checked (installer/deps.py):

• Source code: Xenia's third-party libraries (and rapidjson, for the update check), XenonRecomp, SDL 3, the AMD FidelityFX SDK (headers and the signed FSR and frame generation DLLs), the Intel XeSS SDK (headers, libxess.dll and its license notices; the release archive, of which only those are kept), and NVIDIA's Streamline SDK 2.14.1 (of its release archive, only its headers, its DLLs and NVIDIA's DLSS 310.9 and Reflex DLLs with their licenses are kept; DLSS Frame Generation's aren't installed yet).
• LLVM/Clang 22 (or your system's LLVM 18+ if it has clang-cl, lld-link, llvm-lib and llvm-rc), CMake and Ninja, and on Windows without git, MinGit.
• The Microsoft C/C++ runtime headers/libraries and the Windows SDK, fetched by xwin. These are under Microsoft's license, which you are asked to accept. No Visual Studio installation is needed.

The install folder gets the game files (game/), the program, userdata/ (settings, saves, save backups, installed DLC, logs, the shader cache, and the Options menu it generates), mods/, and with the title update, title_update/. On a PC with an AMD RDNA 4 GPU (Radeon RX 9000 series) and AMD's driver, it also gets neural/: neural rendering's GPU kernels, compiled for that GPU during the install by the driver's own compiler (amd_comgr_3.dll; a minute or two the first time, and again after a driver update), and the shaders it compiles, and DLSS5-AMD/: its settings and logs. An install on a PC without such a GPU removes an earlier install's kernels and shaders (your own files there stay; if AMD's driver can't say which GPU it is, they stay too).

When you save over a save, the version it replaces is kept in userdata/save_backups/: one per save, the one before its latest overwrite (a save the game crashed while writing doesn't replace it). When the old save can't be kept (the drive is nearly full, or it can't be copied) or the new one's folder can't be made, the save isn't overwritten at all: a message over the game says it wasn't saved, and the old one stays. Closing the window while the game is saving waits (10 seconds at most) for the save to be finished. To get one back, open the launcher's Save Backups: it lists them by character, with when each backup and the save in its place were made. Restore puts the backup back (after asking, and not while the game is running), and the save it replaces becomes the backup, so restoring again switches back. (A <save>.new folder in save_backups/ is a backup that couldn't be put in place; the log says why. A <save>~current one is the save a restore set aside, put back when the list is next read with the game closed.)

Playing

• Windows: run DAORecomp.exe in the install folder. The launcher opens first (hold Shift while starting to show it when it is turned off). It is drawn with the title screen and menu art from your copy of the game (guiexport.erf, read at startup; none of it is shipped), falling back to plain shapes without it, and uses Windows' serif fonts (Palatino Linotype, Georgia or Times New Roman). It works with a mouse, the keyboard or any gamepads SDL knows (Xbox, DualSense, DualShock...): the d-pad or left stick moves between items, A/Cross selects, B/Circle goes back, LB/RB (L1/R1) switch Configure's tabs, the right stick scrolls, Start plays. The button hints show the buttons of the gamepad used last. --launcher shows it anyway, --mods opens it on its Mods page, and --play skips it.

  Configure → Advanced → Add to Steam adds the game to Steam as a non-Steam game, for each Steam account on the PC, with library artwork drawn from the title screen. Steam starts it with --play, straight into the game (for Big Picture). Steam has to be closed for that: the launcher asks first, and starts it again after. If Steam gets stuck while closing, the launcher offers to end it after 15 seconds. If Windows still can't let go of it after that, Steam won't start again until the PC is restarted. The old shortcuts.vdf is kept beside it as shortcuts.vdf.daorecomp-backup.

• Linux: the program is a Windows executable; run it with Wine or Proton.

  • Steam: Add a Non-Steam Game → DAORecomp.exe, then in its properties force a Proton version (Proton includes vkd3d-proton for Direct3D 12).
  • Wine: install vkd3d-proton into the prefix (winetricks vkd3d), then run ./run.sh.

  Linux support is untested so far. The program needs Wine's support for placeholder memory views (VirtualAlloc2/MapViewOfFile3) and Direct3D 12 through vkd3d-proton. FSR 4 needs AMD's Windows driver and is unlikely to work under Proton; choose FSR 3.1 in the launcher (XeSS-SR and DLSS are untested there).

Most graphics settings can also be changed in the game: Options → Graphics. Most apply at once; when you leave the menu, the game lists the ones that take effect the next time it starts. Turning off dynamic shadows and post-processing there (or in the launcher) makes the game faster on low-power devices such as the Steam Deck. Motion blur is off by default; Low and High cost GPU time while the scene moves.

Low latency (Configure → Display → Frame rate in the launcher, or Options → Graphics, where it applies at once) turns on AMD Radeon Anti-Lag 2 on AMD GPUs with a current driver, or NVIDIA Reflex on NVIDIA GPUs: each frame starts as late as it can still be on time, so the controller is read closer to when the frame is shown. It does the most when the GPU is the limit (an unlimited frame rate, or one the GPU can't quite reach), where frames would otherwise wait in a queue; at a frame rate the GPU reaches easily there's little to gain. Anti-Lag 2 cost no frames in tests on an RX 9070 XT. It's off while FSR Frame Generation is on: Anti-Lag 2 works with FSR 3's own way of showing generated frames, not this game's, and cost frames with it (Reflex is kept off likewise). On + Boost is Reflex's boost (more GPU clock for lower latency, at some power); on AMD GPUs it's the same as On. On other GPUs it does nothing. userdata/xenia.log says whether it's available and on.

Reflex and DLSS are experimental: they're built on NVIDIA's Streamline (its DLLs and DLSS 4.5's, nvngx_dlss.dll version 310.9, which the installer downloads, next to DAORecomp.exe) without an NVIDIA GPU to test on. Streamline only starts on an NVIDIA GPU, and only when Low latency is on or DLSS is the temporal upscaler as the game starts; turning low latency on from Off there otherwise takes effect at the next start, as does choosing DLSS (the game's Graphics tab says so; if Streamline can't start at all, userdata/xenia.log says why). DLSS uses the presets NVIDIA recommends for each mode (K, and the second generation models M and L for Performance and Ultra Performance); where it can't run (no RTX GPU, an upscaling ratio beyond what DLSS's modes cover, about 3x), FSR upscales instead. The game only loads Streamline's sl.interposer.dll if it's exactly the installer's, and downloads nothing while it runs; NVIDIA's driver may use a newer DLSS it already has.

Neural rendering (experimental, AMD RDNA 4 only): the 3D scenes go through the neural rendering network of NVIDIA's DLSS 5 before temporal upscaling, run on AMD's GPUs by lmxxf's port (MIT), built from its source into LmxxfNrRuntime.dll. The network's weights are NVIDIA's and don't come with the game: download lmxxf's release package (linked from its README), then in the launcher's Configure → Graphics turn on Neural rendering and choose the package's folder with Browse (its folder with block0-ffn.f16 is searched for, four levels down at most; if it isn't found, choose that folder itself). The option is there when the install has its kernels (installed on a PC with an RX 9000 series GPU: install again after changing to one), and needs temporal upscaling on. It's expensive: lmxxf measures about 7 ms of GPU time a frame for its 900-line network and 9.5 ms for 1080 lines on an RX 9070 XT. It works with HDR output too (the network gets the scene in linear light, as DLSS 5 takes HDR, and the highlights above paper white keep their brightness), takes effect when the game starts, and loading the network holds the first frames (the logos) for a second or two. Neural rendering strength (also in Options → Graphics, where it applies at once) sets how much of the network's change of detail and colour is kept, from none (0, which skips the network: no GPU time for it, though it stays loaded; so does anything under 0.05) to all (1). The options lmxxf's packages have are there too (in both; they take effect when the game starts): quality is the network's size, which the 3D scenes are fitted to (Auto picks the smallest they fit: 720 lines at resolution_scale = 1 and 1080 above; 900 and 720 are faster), passes runs the network two or three times a frame for a stronger look (each pass costs as much as the first; the third is predicted from the first two), protect skin keeps skin as the first pass made it, and style is one of NVIDIA's three (0 is NVIDIA's default, 1 lmxxf's). The installer puts lmxxf's settings template for this runtime in DLSS5-AMD/default-config.txt; these settings override it, and the runtime keeps its own logs in DLSS5-AMD/logs. Its problems are logged to userdata/xenia.log, and then it's off for the session. In the game, F6 switches it off and back on at once, to compare, when it was on as the game started (the keyboard only, while the game's window is in front). Ease off neural rendering to hold the frame rate (on by default, in the launcher and in Options → Graphics, where it applies at once) fades the network out while the GPU can't hold the frame rate with it, and back in when the GPU has room for it again; userdata/xenia.log says when ("Frame rate guard"). It measures the GPU's time a frame, so it eases off only when the GPU is what holds the frames back, and does nothing with the frame rate unlimited.

OptiScaler can take over the temporal upscaling (as can unofficial forks of it, such as AMD-NR). It isn't included: copy its files next to DAORecomp.exe without replacing the amd_fidelityfx_*.dll files already there, rename OptiScaler.dll to dxgi.dll, and keep Temporal upscaling on (not Off), since that's what it replaces. A dxgi.dll there runs as part of the game, launcher included, every time it starts, so only use a build you trust. AMD-NR's Neural Rendering is expensive: about 13 ms a frame on an RX 9070 XT at resolution_scale = 2 (1440p) with 4K output, too much for 60 fps; AmdLmxxfTierCap=720 under [DlssNr] in OptiScaler.ini halves that. If the upscaling keeps failing through it, the game falls back to regular scaling for the session, and `userdata/xen