nxdk: an open source SDK for writing homebrew on the original Xbox

The target is the original Xbox, and that decides everything

nxdk is a software development kit for the original Xbox, described as a renewal of OpenXDK and maintained by the XboxDev community. The scope statement in the repository description is precise about which console, calling it the cross-platform, open-source SDK to develop for original Xbox, the new xdk. That distinction matters because the original Xbox is a 2001-era machine with an NVIDIA GPU that wants a particular shader model, and the whole point of an SDK like this is to give you a way to program that hardware without Microsoft's proprietary toolchain. The audience is homebrew and demoscene developers, and the repository topics confirm it, with homebrew, xboxkrnl, xiso, nxdk, and shader among the tags. The status section is candid: while nxdk is still in early stages of development, it can already be used in many projects, and the README points at a wiki list of projects built on top of it.

A portable toolchain built on make and LLVM

The feature list leads with a portable toolchain that works on modern versions of Windows, macOS and Linux, and then with the phrase that decides whether you will like working in it, no complicated cross-compiling or big library dependencies. It builds with `make` and just needs standard tools and llvm. That is a genuine design choice rather than a marketing claim, and you can see it in the Makefile. The toolchain commands are prefixed wrappers, `nxdk-cc`, `nxdk-cxx`, `nxdk-as`, `nxdk-link`, and `nxdk-lib`, and the Makefile selects the NVIDIA Cg compiler binary per platform, with separate paths for Linux, macOS, and MinGW. The Cg binary is a prebuilt executable that ships in the tree rather than something you install, and on MSYS shells the Makefile refuses to run with an error asking you to use a MinGW64 shell. The Makefile also has switches for `DEBUG=y` adding DWARF 4 debug info, `LTO=y` enabling link time optimisation, and `GEN_XISO` producing an ISO alongside the executable.

The prerequisites are ordinary tools plus one awkward requirement

The README lists what you need before anything else. GNU make, clang, GNU bison and flex, lld, Git, and CMake. The bison and flex entries are there because the shader compilers and the resource pipeline generate code at build time, and the wiki has OS specific installation instructions for each prerequisite. The one non-obvious dependency is the NVIDIA Cg compiler, which the README lists separately in the credits as bundled. It is a closed binary tool from the NVIDIA Cg toolkit, so unlike the rest of the toolchain it cannot be rebuilt from source, which is why the Makefile carries platform specific paths to it and why the CI image ships a prebuilt copy. The repository also includes a Dockerfile that builds in a container based on `ghcr.io/xboxdev/nxdk-buildbase`, which is a practical route for teams that do not want to install the whole toolchain on their own machines.

Getting the samples to build is a script and a make

There is no package manager step. You clone the repository with submodules:

    git clone --recursive https://github.com/XboxDev/nxdk.git

The recursive flag matters, because the README's credits show that nxdk incorporates large parts of other projects, including pbkit, an lwIP based network stack, a PDCLib port for the C standard library, parts of LLVM's compiler-rt, Mesa's nvvertparse for the vertex program compiler, and an NVIDIA SDK nvparse for the fragment program compiler. The samples are built by running the activation script `bin/activate`, which spawns a shell fully set up to use nxdk, and then running the Makefile in one of the sample directories. To start your own project, the README says to copy one of the sample directories, run the activation script, and then simply run `make` in the directory of your program. nxdk also supports automatic creation of ISO files, so the build can produce a bootable image as well as the executable, handled by the `extract-xiso` tool, which generates and extracts ISO images compatible with the Xbox and with XQEMU.

The library set is what a real Xbox program needs

The code overview in the README is effectively the feature list. `lib/hal` is a barebones hardware abstraction layer from OpenXDK, `lib/net` is the network stack based on lwIP, `lib/pdclib` is the Xbox port of the CC0 licensed PDCLib C standard library, `lib/pbkit` is a low level library for interfacing with the Xbox GPU, `lib/sdl` holds Xbox ports of SDL2 and SDL_ttf, `lib/usb` is USB support from OpenXDK with parts hacked together from an old Linux OHCI stack, `lib/winapi` has Xbox specific implementations of common WinAPI functions, `lib/xboxkrnl` is the header and import library for the Xbox kernel, and `lib/xboxrt` is miscellaneous debugging functionality. The tools directory holds `cxbe`, a converter from PE executables to the Xbox executable format, `vp20compiler` for vertex program assembly to microcode, `fp20compiler` for register combiner descriptions to pushbuffer commands, and `extract-xiso`. SDL2 support for input, audio and 2D graphics, plus Windows API and BSD sockets, is what makes porting existing software realistic.

Samples show which features are actually usable today

The samples directory is the honest measure of coverage. It holds `hello` and `hello++`, `triangle` for 3D, `gamma` and `gamma-fade` for display gamma handling, `led` and `mesh` for hardware features, `httpd` and `httpd_bsd` for the network stack, `sdl`, `sdl_gamecontroller`, `sdl_image`, and `sdl_ttf` for the SDL2 ports, `usb` for the USB stack, `winapi_drivelist` and `winapi_filefind` for the WinAPI subset, and `xaudio` for audio. The README describes the samples as showing how to use common features, and the CI workflow badge is for Build Samples, so the samples are continuously compiled. The 3D path is the unusual part, because the original Xbox GPU does not run modern shaders, so nxdk provides a custom API using NVIDIA designed shader languages with additional Xbox extensions, and you compile vertex and fragment programs with the bundled NVIDIA tools into the microcode the hardware expects.

Licensing is per component, and the container label spells it out

GitHub reports the repository licence as unknown, which is a symptom of how the project is assembled rather than an oversight. The credits section attributes each part separately. OpenXDK and large parts of pbkit are MIT, the lwIP based network stack is Modified BSD, the PDCLib C library is CC0, large parts of the runtime library are derived from LLVM's compiler-rt under MIT, vp20compiler is based on Mesa's nvvertparse under MIT, fp20compiler is based on nvparse from the NVIDIA SDK 9.52, and extract-xiso is BSD. The Dockerfile at the repository root makes the combined position explicit in an image label: Apache-2.0 AND BSD-3-Clause AND CC0-1.0 AND GPL-2.0-or-later AND MIT. The repository has a `LICENSES/` directory for the per-component texts, and the Dockerfile itself is marked CC0-1.0 with an SPDX header. The last push was on 2026-09-30, the project publishes no GitHub releases, and the README says it is supported by an active community that responds to bug reports.

Editorial conclusion

nxdk fits a developer who wants to write or port software for the original Xbox and wants a toolchain that builds on the operating system they already use, rather than the original Microsoft's environment. It is the wrong choice if you are building for the Xbox One or Series consoles, since this is the original Xbox, and it is the wrong choice if you need a stable release to pin, since the README describes the project as still in the early stages of development and the repository publishes no releases. Before you start, read the prerequisites page in the wiki, because the NVIDIA Cg compiler and the shader toolchain have platform specific quirks, and treat the sample list as the specification of what actually works today.

Frequently asked questions

Official sources

1. Issues
2. README
3. XboxDev/nxdk on GitHub