ClassicUO reimplements the Ultima Online classic client in C#

What the client is, and what it is not

ClassicUO is an open source implementation of the Ultima Online Classic Client. The client is intended to emulate all standard client versions and is primarily tested against Ultima Online free shards.

That last clause is the key to the project's scope. The client is a reimplementation of the original 1997 game client, written to talk to a server, and the servers it is tested against are the free shards that anyone can join. It is not a server emulator. The server side of Ultima Online is a separate body of work, and this repository contains only the client.

The reason to reimagine a two decade old client at all is that the original is DirectX-era Windows software that most people can no longer run comfortably. ClassicUO replaces the rendering and input layer with modern cross platform back ends while keeping the protocol and the game rules intact, so the game plays the way it was designed to play on hardware that still exists.

The C# choice is explained in the README with three reasons. There is a large community of developers working on Ultima Online server emulators in C#, so the ecosystem exists, FNA-XNA exists and seems reasonably suitable for creating this type of game, and the client is written on top of that framework. The project is described as currently under heavy development but is functional.

The rendering backends and the platforms they cover

ClassicUO is natively cross platform, and the list of backends is specific enough to be worth quoting in full.

The browser entry is Chrome. Windows supports DirectX 11, OpenGL and Vulkan. Linux supports OpenGL and Vulkan. macOS supports Metal, OpenGL and MoltenVK.

That coverage is what the FNA-XNA framework buys. FNA is a reimplementation of Microsoft's XNA game framework, and it is the backend layer that lets one codebase talk to DirectX on Windows, OpenGL and Vulkan on Linux, and Metal through MoltenVK on macOS, rather than the project maintaining three renderers of its own.

The browser entry is the most unusual of the four, and it is where a hosted build would sit. The project also publishes a play link at play.classicuo.org, and the repository carries a GitHub Actions workflow for Deploy alongside the Build-Test one, which is consistent with a client that is meant to be run from a browser without a local install.

The repository topics list cross-platform, directx-11, opengl, vulkan, fna-xna, games and ultima-online, which matches the backends described.

Downloading a build and building one yourself

There is a downloadable launcher for each desktop platform and a hosted browser build, so most people never need a compiler.

The table in the README points to the browser build at play.classicuo.org, a Windows x64 launcher zip under classicuo.eu/launcher/win-x64/, a Linux x64 zip under classicuo.eu/launcher/linux-x64/ and a macOS x64 zip under classicuo.eu/launcher/osx/. The project site itself is classicuo.eu.

To produce a release build from source, the sequence is three steps:

git clone --recursive https://github.com/ClassicUO/ClassicUO.git
cd ClassicUO/scripts
bash build-naot.sh

The --recursive flag on the clone matters. The repository has a .gitmodules file and an external directory, so the submodules carry the FNA backend and other third party sources, and a shallow clone without them will fail at the build step rather than at the clone step.

The binaries end up in the bin/dist folder. The script is a shell script, and the README warns that to execute .sh scripts on Windows you should use Git Bash, which can be installed with Git itself.

The solution file is ClassicUO.sln, with a .sln.DotSettings file next to it, and the top level is a conventional C# layout with src, tests, tools, scripts and external directories. The presence of a tests directory is worth noting for a game client, since a graphics-heavy client usually has little in the way of automated coverage.

The legal boundary the README draws

The Legal section is the most consequential part of the README, and it deserves to be read rather than skimmed.

The code itself has been written using the following projects as a reference, and those are named: OrionUO, Razor, UltimaXNA and ServUO. The backend is FNA. That is an unusually complete attribution list, and it tells you that this is a from-scratch reimplementation informed by several existing open source projects rather than a clean-room effort.

Then the constraint: this work is released under the BSD 4 license, this project does not distribute any copyrighted game assets, and in order to run this client you will need to legally obtain a copy of the Ultima Online Classic Client.

So the assets are the dividing line. The code is open, the artwork and sounds are not, and the user supplies the legitimate copy. The README also states that using a custom client to connect to official UO servers is strictly forbidden, and that the project does not assume any responsibility of the usage of this client.

The final line is the trademark notice: Ultima Online is copyright Electronic Arts, all rights reserved.

On the licence itself there is a discrepancy worth flagging. GitHub shows BSD-2-Clause in the licence field, while the README says BSD 4. Those are different licences with different clauses, and the LICENSE.md file at the root is the authoritative text if you need to know which terms actually apply. The copyright header file ClassicUO.licenseheader in the repository root suggests the per-file header text is worth reading as well, since that is often where the real terms live in a project like this.

Funding, signing and how releases are cut

The project asks for money twice, and it is worth being clear about why before deciding whether that matters to you.

The README asks individuals and hobbyists to support continued maintenance and development via the monthly Patreon, and also via PayPal. A Discord badge is included for chat. This is a project maintained on the back of a small number of donors rather than a company product, and the monthly framing means the funding is a running cost rather than a one-off sponsorship.

Releases are cut through GitHub Actions, with two workflows visible in the README, a Build-Test badge and a Deploy badge. The release names are interesting because they are not version numbers in the usual sense: the tags are ClassicUO-main-release dated 2025-11-04, ClassicUO-beta-release from 2025-10-28 and a dev release from 2024-01-22. The naming suggests a rolling release channel per branch rather than a single numbered line, and the last push on 2026-10-16 is well after the newest listed tag, so the main channel moves often.

Windows binaries are signed, through free code signing provided by SignPath.io with a certificate from the SignPath Foundation. For a project that asks users to download an unsigned game client, that is a meaningful detail, because it lets Windows distinguish the build from an arbitrary executable of the same name.

The README also carries a privacy statement: this program will not transfer any information to other networked systems unless specifically requested by the user or the person installing or operating it. For a client that talks to a game server, that statement is narrower than it sounds, and it is about the client rather than the server.

Where ClassicUO fits against the alternatives

The comparison that matters is with the other open source Ultima Online clients, and the named references give the shape of the field.

OrionUO is the older project that ClassicUO was written with as a reference, and it is a Windows DirectX client. UltimaXNA is a .NET reimplementation of the XNA framework itself, which means it depends on a Microsoft runtime rather than the open FNA replacement. ServUO is on the server side of the ecosystem, an emulator rather than a client. Razor is a macro and automation tool that has been part of the scripting scene in Ultima Online for a long time, and the README lists it among the projects the code was written with as a reference.

So the field divides along two lines. Server or client, and closed platform or open one. ClassicUO sits at the open client end, and it is the one that can be built for a browser as well as three desktop platforms, which none of the older Windows-only clients can offer without a rewrite.

The practical difference for a user comes down to which shard and which client build they need. A free shard operator who wants their players on Linux or in a browser needs something like this. A player who only wants to connect to a modern official-style shard with no custom client and no macro automation has no reason to install it at all, and the README's rule about official servers applies to them too, since the original client still works there.

Editorial conclusion

ClassicUO suits a player or server operator who wants the classic Ultima Online client running on a modern platform, in a browser, or on a free shard, since the project exists to emulate the standard client versions rather than to host a game. It is the wrong tool if you want a server emulator, because the client and the server are separate programs, and it is the wrong tool if you do not hold a copy of the original client, because the assets are not distributed. Before building from source, read the Legal section, because the README requires a legally obtained copy of the Ultima Online Classic Client and forbids connecting a custom client to official UO servers, then run the build-naot.sh script in scripts/ to produce binaries in bin/dist.

Frequently asked questions

Official sources

1. ClassicUO/ClassicUO on GitHub
2. License: BSD-2-Clause
3. Project website
4. README
5. Releases