# Oolite is an open source Elite clone built to be reshaped by expansion packs

> Oolite is an Objective-C open source reimplementation of Elite that ships as a native game on Windows, Linux and macOS, with a large extension system called OXP that adds ships, modifies gameplay and replaces graphics. It suits a player who wants the 1984 trading and combat loop in a modern open world, and it is a fork of the original game's assets rather than a from scratch engine.

**OoliteProject/oolite** — The main Oolite repository.

- Repository: https://github.com/OoliteProject/oolite
- Website: https://www.oolite.space
- Stars: 674 · Forks: 85
- Language: Objective-C
- License: NOASSERTION
- Published: 2026-10-21 · Updated: 2026-10-21 · Language: en
- Canonical page: https://hysenlabs.com/projects/ooliteproject-oolite

## The premise is a reimplementation, not a new game

The project describes itself as an open source Elite clone on steroids, and the README states that while it can run just like the original but on modern computers, it can also be vastly modified through Oolite Expansion Packs. That framing sets the expectation correctly. This is a reconstruction of a specific 1984 game rather than an original space trading title, and the words in the repository description carry the argument. The target audience is a player who wants the trading, combat and upgrade loop in a modern open world, plus the people who write the expansions. The project has its own homepage at oolite.space, its own wiki on the Elite Wiki at wiki.alioth.net, its own bulletin board at bb.oolite.space and its own documentation site at oolite.readthedocs.io, which is the level of infrastructure of a long-lived independent project rather than a single repository.

## Expansion packs are the real product, and they run on the wiki platform

The customisation story is stated plainly: Oolite can be heavily customized via expansions, which modify the gameplay, add ships, improve graphics, and the possibilities are almost endless. That is the core of the project and the reason it has survived as long as it has. Each expansion is an OXP, and the gallery the README links to is hosted on addons.oolite.space, so the extension ecosystem has its own distribution and catalogue site separate from the game repository. A designer can ship a new ship, a new system, a revised interface or a total conversion without touching the engine. The README points people to the Oolite Bulletin Board as a friendly community of Oolite fans and developers. For an engineer reading the repository, the practical consequence is that the interesting code is often not in src/ at all, and the documentation site plus the expansion catalogue are where the real knowledge lives.

## Three platforms, three packaging models, and one of them is missing

The release table at the top of the README is the fastest way to understand the distribution situation, and it carries an important limitation. Windows gets an NSIS installer, a test installer and a deployment-to-test release executable. Linux gets an x86_64 AppImage and a Flatpak named space.oolite.Oolite. The macOS column is empty except for a note, and the note says OSX is not supported for v1.92. The current release tags are 1.93.1-229 from 2026-10-17, 1.93.1-227 and 1.93.1-226 both from 2026-09-24, and the table still shows 1.92.1 artefacts, so the table and the release history are describing slightly different points in the line. The repository is not archived and the last push was on 2026-10-17, the same day as the newest tag, so the code is current even where a platform has been dropped. The project homepage, wiki, forum and documentation are all linked from the README, and the licence is a custom one that GitHub cannot classify, held in LICENSE.md at the root.

## Installing on Linux is a chmod and a run, with a Flatpak as the tidier option

The installation instructions are short because the artefacts are self-contained. You download the latest version from the releases page. On Windows the NSIS installer is named OoliteInstall-XXX-win.exe where XXX is the version number, and you double click it. On Linux there are two routes. The Flatpak is named space.oolite.Oolite_XXX.flatpak, and the documentation notes that many Linux package managers support Flatpak so you should be able to double click the downloaded file to install it. The AppImage is named Oolite_XXX-x86_64.AppImage, and you download it to where you would like it stored, make it executable and run it:

```bash
chmod +x Oolite_XXX-x86_64.AppImage
./Oolite_XXX-x86_64.AppImage
```

That is the whole Linux install. The Flatpak route is the one to prefer if your distribution handles it, since it gives you sandboxing and an update path, while the AppImage is the one that always works because it carries its own dependencies.

## Building from source needs a toolchain per platform and root on Linux

The source build is documented for developers, and the README says the scripts require sudo for activities like installing dependent libraries built from source and for installing packages on some Linux distros, with the bulletin board offered for help if you hit difficulties. The first step is git, and the checkout is done with a partial clone that skips blobs:

```bash
git clone --filter=blob:none https://github.com/OoliteProject/oolite.git
cd oolite
```

On Windows you then double click Run Me in ShellScripts/Windows or run the setup script from a command prompt, which installs MSYS2 with its MinGW environments, and you are asked for the install location and whether you want the Clang build, which is recommended, or the GCC build. The Clang build uses the UCRT64 environment and the GCC build uses MINGW64. The repository top level reflects the multi-platform structure, with ShellScripts/ for those setup scripts, src/ for the Objective-C sources, Resources/ for assets, installers/, debian/ for packaging, meson.build and meson.options for the build definition, plus tests/, tools/, Doc/ and Documentation/. There is also a clang-format configuration and a build-all workflow with a separate clang-format check job, so the formatting is enforced in CI.

## The Objective-C codebase carries a decades of Apple platform assumptions

The primary language is Objective-C, and that is more than an implementation detail for a project that has been running for years on Apple platforms. The build environment for the modern versions involves MSYS2 and MinGW on Windows and a Linux toolchain, but the historical shape of the code still comes from a Mac-first Objective-C codebase, and the resources and the platform integrations reflect that. The repository also carries a DebugOXP/ directory, which is a development expansion pack shipped inside the tree rather than in the public catalogue, so the expansion mechanism is exercised by the core project itself. API documentation is published at oolite.readthedocs.io alongside the player documentation, which tells you the project treats its Objective-C interfaces as a public surface for the expansion authors rather than an internal detail.

## The package.json is a stub and the real build is Meson

One detail in the repository is worth flagging because it misleads anyone who assumes a modern JavaScript project. The root package.json names the project oolite at version 1.0.0, lists an eslint devDependency and a test script that echoes an error and exits with status 1, meaning no test is specified. Its licence field says ISC. None of that describes the game, because the game is not built with npm. The actual build is driven by meson.build and meson.options, with a makefile-style mk.sh script, a .clang-format file and clang.ini and gcc.ini configuration files for the two compiler paths, and ShellScripts/ for per platform setup. The .eslintrc.json in the root is for the JavaScript tooling that ships with the web assets rather than for the engine. The practical point is that a contributor should not expect npm to build this project, and the windows and Linux setup scripts are the entry points.

## Where Oolite is the wrong choice

Three situations argue against it. The first is a player who wants a modern space combat game rather than a reconstruction. Oolite's appeal depends on you already knowing Elite and wanting that specific loop, because the structure is a freeform open world with no conventional mission campaign, and a newcomer looking for a story will find the early game opaque. The second is a developer who wants a modern game engine. This is an Objective-C codebase built around a desktop game from the 2000s, with its own resource format, its own scripting layer for expansions and a build setup that needs MSYS2 or a Linux toolchain with sudo. It is not a Unity or Godot style engine you would base a new commercial game on. The third is any commercial redistribution without reading the licence. The hosting service reports the licence as one it could not classify, and while the package.json metadata says ISC, that field describes a JavaScript stub rather than the game, so the LICENSE.md file at the root is the document that governs what you may do with Oolite and with the assets derived from the original game. The realistic alternative for someone who simply wants to play in that genre is a commercially released Elite: Dangerous, which is the game Oolite is modelled on and which comes with the full official campaign.

## Conclusion

Adopt Oolite if you want the Elite loop running in an open source engine you can extend with expansion packs, and expect to spend time in the expansion ecosystem rather than in the core code. Skip it if you need a modern space combat game with a conventional campaign structure, or if you want a project that will not carry a custom licence. Verify first which platform builds you need, because the release table notes that macOS was not supported for version 1.92, and read LICENSE.md before redistributing anything you build on top of it.

## FAQ

### What is Oolite?

Oolite is an open source Elite clone written in Objective-C. While it can run just like the original on modern computers, it can also be modified extensively through Oolite Expansion Packs, which change gameplay, add ships and improve graphics.

### How do I install Oolite on Linux?

Download either the Flatpak named space.oolite.Oolite_XXX.flatpak, which many Linux package managers support and install by double click, or the AppImage named Oolite_XXX-x86_64.AppImage, which you make executable with chmod +x and then run.

### What are Oolite expansion packs?

They are modifications distributed as OXPs that modify the gameplay, add ships and improve graphics, and they are catalogued on addons.oolite.space rather than in the main repository. The repository also ships a DebugOXP directory for development purposes.

### Is Oolite still maintained?

The repository is not archived and the last push was on 2026-10-17, the same day as the newest tag 1.93.1-229, with 1.93.1-227 and 1.93.1-226 from 2026-09-24. The release table notes that macOS is not supported for version 1.92.

### How do I build Oolite from source?

Clone the repository with git clone --filter=blob:none and change into it. On Windows you run the setup script in ShellScripts/Windows, which installs MSYS2 and lets you choose a Clang build using UCRT64 or a GCC build using MINGW64, and the Linux instructions require sudo for installing dependent libraries.

## Sources

- [Issues](https://github.com/OoliteProject/oolite/issues)
- [OoliteProject/oolite on GitHub](https://github.com/OoliteProject/oolite)
- [Project website](https://www.oolite.space)
- [README](https://github.com/OoliteProject/oolite/blob/master/README.md)
- [Releases](https://github.com/OoliteProject/oolite/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/ooliteproject-oolite