# Octave targets consoles from one C++ engine, and its development is paused

> Octave is a 3D game engine in C++ that builds for GameCube, Wii, 3DS, Windows, Linux and Android, with Lua scripting and a level editor. It suits a developer who wants one codebase across those platforms, and the project itself says development is on hiatus and points you to a successor.

**mholtkamp/octave** — A 3D game engine for GameCube, Wii, 3DS, Windows, Linux, and Android.

- Repository: https://github.com/mholtkamp/octave
- Stars: 530 · Forks: 34
- Language: C++
- License: MIT
- Published: 2026-10-22 · Updated: 2026-10-22 · Language: en
- Canonical page: https://hysenlabs.com/projects/mholtkamp-octave

## One engine, six targets, and a Lua layer for game logic

The scope is stated in a single line: Octave is a 3D game engine for GameCube, Wii, 3DS, Windows, Linux, and Android. What makes that more than a list is the structure the repository shows. The `Engine/` directory holds the engine itself, `Standalone/` holds the desktop level editor, `Template/` is a project template, `External/` holds third-party code, and `Documentation/` carries the Lua documentation, the Docker documentation and the editor hotkeys page. The scripting decision is Lua, and the documentation for it is a first-class part of the tree rather than a wiki page, which tells you the engine is designed around writing game logic in a scripting language rather than in C++. That is the shape of most modern engines, and for a multi-platform team it is the part that matters most, because the parts that have to be recompiled for the GameCube are the parts you write once.

## The Windows path is Visual Studio plus two devkitPro toolchains

Building on Windows is documented as a fixed sequence, and the dependency list explains the design. You need Visual Studio Community 2022 with C++ support, the Vulkan SDK at version 1.3.275.0 with the Shader Toolchain Debug Symbols 64 bit option selected, devkitPPC for GameCube and Wii development, and devkitARM for 3DS development. The devkitPro toolchain installation instructions are in the devkitPro wiki. Shaders are built separately by running compile.bat in `/Engine/Shaders/GLSL`, and then you open Octave.sln, switch to the DebugEditor solution configuration, set the Standalone project as the startup project, change the working directory in the debug settings to `$(SolutionDir)`, and build. The documentation notes that the standalone level editor is what you get if you were making a game with Lua script only, which is the intended quick start for a scripting-led project.

## GameCube packaging on Windows is the part that fights back

One platform has a genuine friction point, and the documentation is candid about it. GameCube packaging currently only works on Linux or Docker, and the recommendation is to build GameCube games on Windows with Docker. The manual Windows route exists, and it is a sequence of devkitPro pacman steps. You launch `devkitPro > MSys2` from the Start Menu, receive and locally sign the libogc2 key with `pacman-key --recv-keys` and `pacman-key --lsign-key` against keyserver.ubuntu.com, and add a repository entry to `C:\devkitPro\msys2\etc\pacman.conf` above the `[dkp-libs]` entry:

```
      [libogc2-devkitpro]
      Server = https://packages.libogc2.org/devkitpro/windows/$arch
      Server = https://packages.extremscorner.org/devkitpro/windows/$arch
```

Then you run `pacman -Syuu` and `pacman -S gamecube-tools-git libogc2 libogc2-libdvm`, accepting the overwrite if asked, and restart the machine if you had Visual Studio open before installing `libogc2` so that the environment variables are found. A Linux host has the same shape of procedure with `dkp-pacman` instead, and the same repository block pointing at the linux archives.

## On Linux the editor is two make targets and a specific working directory

The Linux path is the shortest of the three, and it is also the one the Docker system is meant to replace. The dependencies for Debian and Ubuntu based distributions are `sudo apt install g++ make libx11-dev libasound2-dev`, and for Arch based distributions `sudo pacman -S gcc make libx11 alsa-lib`, with a note that Arch users may hit a dependency error on `alsa-lib` and should try `lib32-alsa-lib`. The Vulkan SDK is installed by extracting the 1.3.275.0 tar file and adding four environment variables to `~/.bashrc` or to a script in `/etc/profiles.d`:

```
  export VULKAN_SDK=~/VulkanSDK/1.3.275.0/x86_64
  export PATH=$VULKAN_SDK/bin:$PATH
  export LD_LIBRARY_PATH=$VULKAN_SDK/lib${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}
  export VK_LAYER_PATH=$VULKAN_SDK/share/vulkan/explicit_layer.d
```

The editor build is then two commands. You change into the `Standalone` directory and run `make -f Makefile_Linux_Editor`, then you go back to the root and run `Standalone/Build/Linux/OctaveEditor.elf`, with the emphasis that the working directory must be the root directory where the Engine and Standalone folders live. Shaders are compiled separately by changing into `Engine/Shaders/GLSL/` and running `./compile.sh`. Visual Studio Code is also supported, by opening the root folder, installing the C/C++ Extension Pack, and selecting the `Octave Editor` launch configuration.

## Packaging for Android pins a specific toolchain triple

Android is the platform with the most version-pinned requirements in the documentation, and those pins are a useful signal about what the project was last verified against. Packaging for Android requires Android Studio, last tested with Android Studio 2022.2.1 Patch 2, with three tools installed through the SDK Manager: Android SDK Build Tools at 34.0.0, Android NDK side by side at 25.2.9519653, and CMake at 3.22.1. The documentation also notes that packaging for any platform from a Windows machine will likely need Msys2 so that Linux commands can be executed, and that this comes packaged with the devkitPro libraries, so installing those removes the concern. CMake support is described as a work in progress where only Linux support has been implemented and tested, and the tips for trying it are to pull all submodules with `git submodule update --init --recursive`, install pkg-config and install the vorbis dev libraries with `sudo apt install libvorbis-dev`.

## Docker is the reproducible path across every supported platform

The Docker documentation describes a build system intended for reproducible builds across all supported platforms, with the additional property that you can build Octave itself from source without installing any dependencies on the host machine. That is the strongest argument in the documentation, because the dependency lists above are long and full of version pins: a Visual Studio install, two Vulkan SDK versions, four devkitPro toolchains, an Android Studio with three pinned SDK components, and a separate shader compilation step. Reproducibility across all of those is a claim worth taking seriously, and the alternative, building the same project on a different machine by hand, is exactly the situation where a Linux package mirror, an SDK version and a shader compile step drift apart. The Docker directory is at the repository root next to `Engine/`, `Standalone/` and `External/`, and the Docker documentation lives under `Documentation/Docker/`.

## The hiatus notice and the successor are the first things to read

The most consequential paragraph in the documentation is the one labelled Development Hiatus. Development of Octave is currently paused, and pull requests are welcomed but they may not be merged any time soon. The project then points at Polyphase Engine as a more modern, greatly improved version, with a list of what it adds: visual scripting, a timeline animation system, an internal Lua editor, Lua IntelliSense and auto-completion with VsCode, editor themes, window docking, 3DS and game preview, skybox rendering, native C++ addons and plugins, and more. This is a well-behaved project handover. Rather than leaving a stale repository, the author states the situation and names where to go. For a maintainer or a learner, the precompiled standalone builds on the Releases page plus the Lua documentation under `Documentation/Lua/` remain usable artefacts, and the version tags show the shape of the history, with Version 6 on 2026-03-24, Version 5 on 2026-01-06 and Octave Alpha 4 on 2025-11-29.

## Where a cross-platform engine stops being the right answer

Two limits are visible in the documentation. The first is the platform list itself. Six targets, two of which are closed consoles with their own toolchains, means the build matrix is not one Visual Studio project but a per-platform pipeline with per-platform packaging rules, and the GameCube path on Windows already shows what that costs. The second is the hiatus. A paused project is a perfectly good base for someone who wants to learn from the code or ship a game they never need to update, and a poor foundation for a studio whose publisher will ask for a new platform in two years. The alternative to weigh against is a modern engine with a live community and a plugin ecosystem, which is what the project itself recommends. The difference in approach is that a paused engine freezes a set of platform decisions you inherit whole, while a maintained engine lets you take the platform story incrementally. If the console targets are the reason you are here, and you are prepared to own the toolchain maintenance yourself, Octave saves you from writing a renderer, a scene graph and a build pipeline for GameCube and 3DS. If you need that maintenance to come from someone else, the successor the project names is the better starting point.

## Conclusion

Octave is worth using if your target list spans a console and a desktop and you want a single C++ codebase plus Lua scripting rather than two engines, since the Docker build system covers all supported platforms and the standalone editor is built from source with a documented Visual Studio configuration. It is a poor fit for a new project that needs ongoing upstream fixes, because the development hiatus notice says pull requests are welcomed but they may not be merged any time soon, and the project itself recommends a different engine. It is also a poor fit if you need console packaging on a Windows host without Docker, since the documentation says GameCube packaging currently only works on Linux or Docker. Before adopting it, read the Development Hiatus section, check the precompiled standalone builds on the Releases page against the version you need, and note that the last push to the repository was on 2026-04-25, with the Version 6 tag published on 2026-03-24.

## FAQ

### What platforms does the Octave game engine target?

Octave is a 3D game engine for GameCube, Wii, 3DS, Windows, Linux, and Android. It is written in C++ with Lua scripting, and the repository holds the Engine directory, the Standalone desktop level editor, a project Template and the Documentation tree.

### How do I build the Octave editor on Linux?

Install the dependencies, set up the Vulkan SDK environment variables, compile the shaders by running ./compile.sh in Engine/Shaders/GLSL, then change into the Standalone directory and run make -f Makefile_Linux_Editor, and finally run Standalone/Build/Linux/OctaveEditor.elf from the repository root so that the Engine and Standalone folders are found.

### Can I package a GameCube game from Windows?

GameCube packaging currently only works on Linux or Docker, and building on Windows with Docker is the recommended route. The manual Windows route exists through devkitPro MSys2 pacman steps including adding the libogc2 repository to pacman.conf and installing gamecube-tools-git, libogc2 and libogc2-libdvm.

### Is the Octave engine still being developed?

No. The documentation carries a Development Hiatus notice saying development of Octave is currently paused, that pull requests are welcomed but may not be merged any time soon, and that for a more modern and greatly improved version you should look at Polyphase Engine, which adds features such as visual scripting, a timeline animation system, an internal Lua editor and native C++ addons.

## Sources

- [Issues](https://github.com/mholtkamp/octave/issues)
- [License: MIT](https://github.com/mholtkamp/octave/blob/main/LICENSE)
- [mholtkamp/octave on GitHub](https://github.com/mholtkamp/octave)
- [README](https://github.com/mholtkamp/octave/blob/main/README.md)
- [Releases](https://github.com/mholtkamp/octave/releases)

---

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