# sm64coopdx: Online Multiplayer and Lua Mods for Super Mario 64 PC

> sm64coopdx extends the Super Mario 64 PC port with synchronized multiplayer, shared enemies, level events, and a Lua API. It suits players seeking cooperative sessions and modders working in C or Lua, but building it requires the project toolchain and game assets.

**coop-deluxe/sm64coopdx** — An official continuation of https://github.com/djoslin0/sm64ex-coop on sm64coopdx for the enhancements and progress it already has.

- Repository: https://github.com/coop-deluxe/sm64coopdx
- Website: https://sm64coopdx.com
- Stars: 1,517 · Forks: 382
- Language: C
- License: not declared
- Published: 2026-10-16 · Updated: 2026-10-16 · Language: en
- Canonical page: https://hysenlabs.com/projects/coop-deluxe-sm64coopdx

## What sm64coopdx Adds to the Super Mario 64 PC Port

sm64coopdx is an official continuation of sm64ex-coop, a project created by djoslin0. Its stated initial goal was to add online multiplayer to the Super Mario 64 PC port, and the README describes that goal as accomplished. The distinguishing technical claim is that the project synchronizes all entities and every level for multiple players. That includes enemies and events, so participants are not limited to synchronizing only their own characters in an otherwise independent level.

This shared-world model targets players who want to encounter the same enemies, alter the same level state, and experience events together. The repository also names modders as an audience. Its Lua API is intended to let players and modders customize the game, while the C documentation and extensive source layout provide a lower-level extension path for contributors. The README compares the scripting model to the Lua APIs used by Roblox and Garry's Mod, although it does not claim API compatibility with either product.

The project does more than add multiplayer in the narrow sense. Its Makefile exposes compile-time options for Raspberry Pi, RK3588, Discord, CoopNet hosting, automatic updates, unsafe Lua standard-library access, and platform-specific compilation. Those options show that distribution, deployment, and server integration are part of the project's build surface. They also mean that installing sm64coopdx is not equivalent to installing a small desktop package.

## Shared Entities and Events Shape the Multiplayer Model

The core architecture described by the repository is a modified C PC port with network synchronization around entities and levels. According to the README, enemies and events are synchronized along with all entities and every level. In practical terms, that means the multiplayer session operates on a common game state rather than treating each player's level as an isolated room. When players encounter the same world object, the project treats that object's state as part of what must be kept aligned across participants.

The repository root supports this interpretation. Directories such as `actors`, `levels`, `data`, `src`, `include`, `dynos`, and `mods` divide game assets, game systems, native code, and extensions into identifiable areas. The `dynos/` tree appears alongside build logic in `Makefile`, `Makefile.split`, and `dynos.mk`, while `mods/` provides a distinct location for packaged modifications. Based on this layout, Lua and native C are separate extension surfaces with documentation under `docs/lua/lua.md` and `docs/c/c.md`.

This design also sets limits on what can safely be changed. A mod that creates unsynchronized state may conflict with the project's shared-world model, although the README does not document the exact replication rules or conflict-resolution behavior. The repository does not describe authority ownership, packet behavior, lag compensation, save synchronization, or host migration. Those details must not be inferred merely from the claim that entities and levels synchronize.

## Building a Headless sm64coopdx Docker Image

The README does not provide a short binary installation tutorial. It directs users to the project website and community resources, while the checked-in `Dockerfile` supplies a Linux build environment. The documented Docker invocation builds an image named `sm64coopdx`. It mounts the current repository directory into `/sm64`, runs `make` with the `HEADLESS=1` option, and removes the container after the command exits.

Run these commands from the repository root. The image build installs the compiler and supporting packages listed by the `Dockerfile`. After the image is created, the container invokes the repository's Makefile against the mounted working tree:

```bash
docker build -t sm64coopdx .
docker run --rm --mount type=bind,source="$(pwd)",destination=/sm64 sm64coopdx make -j HEADLESS=1
```

The `Dockerfile` points to the upstream `n64decomp/sm64` README for advanced usage. No complete build output is provided there, so successful artifact names, required game asset locations, and launch arguments are not documented in this repository excerpt. The top-level `sm64.us.sha1`, `sm64.jp.sha1`, `sm64.eu.sha1`, and `sm64.sh.sha1` files indicate that game versions are relevant to the build tree, but the README does not explain how a user supplies those assets.

For a native build, the Makefile is the project-level entry point and `util.mk` supplies shared build logic. The README does not publish the full native dependency sequence, so copying the Docker package list into a host installation would be an unsupported shortcut.

## Lua, Native C, and CoopNet Build Choices

The extension model gives sm64coopdx two distinct development paths. Lua is the documented choice for getting started with modding and customization. Native contributors are directed to the C documentation, which is consistent with the project's primary language and its source directories under `src/` and `include/`. The README does not provide a mod manifest example, load command, or API call, so a complete Lua workflow cannot be reconstructed from the README alone.

Build options are passed with `make SETTING=value`. That mechanism matters because multiplayer integration is not entirely detached from the rest of the build. The Makefile enables the Discord Game SDK for Discord invites and CoopNet for CoopNet server hosting by default. It also enables the updater by default. A deployment that does not need one of these services can disable its corresponding build setting, but the Makefile does not explain the runtime consequences of removing each SDK.

The `LUA_UNSAFE` option deserves particular attention. Its own Makefile warning describes standard-library code that is normally disabled because it may cause severe accidents. It defaults to `0`. Enabling it is therefore not a routine optimization or convenience switch. The project explicitly conditions use on knowing why it is needed and taking risk-reduction measures.

Other documented choices include `TARGET_RPI`, `TARGET_RK3588`, `TARGET_ARCH`, `TARGET_BITS`, `OSX_BUILD`, `DEBUG`, `DEVELOPMENT`, and `OPT_LEVEL`. Options are passed with the same `make SETTING=value` convention, and the Makefile warns that `make clean` may be required after changing some settings.

## Where sm64coopdx Differs from the PC Port and Its Predecessor

The clearest real alternative described by the repository is the unmodified Super Mario 64 PC port. The port provides the game without sm64coopdx's multiplayer synchronization layer, Lua customization API, Discord integration, CoopNet hosting, updater, or listed platform build options. sm64coopdx adds a shared online session model in which entities, enemies, events, and levels are synchronized. This is a larger architectural change than a conventional save, graphics, or gameplay modification because client state participates in a multiplayer simulation.

The other relevant alternative is sm64ex-coop, created by djoslin0. sm64coopdx does not present itself as a competing reimplementation with the same feature set. The repository describes it as an official continuation intended to retain and advance the predecessor's enhancements and progress. Potential users comparing the two should therefore treat lineage as relevant: sm64coopdx adds continued development, a Lua API emphasized in its README, and its own build configuration. The README does not provide a version-by-version migration guide for mods or sessions created with sm64ex-coop.

This distinction also prevents a misleading conclusion from the name “mod.” Although the README calls it a multiplayer mod, the checked-in repository includes its C implementation, build system, game levels, assets, tools, updater, and platform SDK integration. It is better evaluated as a maintained fork and multiplayer platform built around the PC port.

## Maintenance, Licensing, and Upgrade Boundaries

The repository is not archived, and the last push was on 2026-10-08. Recent published releases include v1.5.1 on 2026-06-01, v1.5 on 2026-05-28, and v1.4.1 on 2026-01-01. Those dates establish recent project activity, but they do not establish the cost of upgrading a particular installation. The README does not describe migration procedures, compatibility guarantees between releases, or whether existing Lua mods remain compatible.

The repository's license field is unknown. The README links to public bug reporting, contribution, Discord, and wiki resources, but those links do not grant reuse rights or settle licensing for the code, bundled assets, SDKs, and game data. No legal interpretation should be made until license files and applicable notices have been checked directly in a release.

Game-data handling is another adoption boundary. The repository is a derivative project centered on Super Mario 64, and the root includes checksums for several regional game files. The README does not state a lawful asset-distribution workflow, nor does it promise that the Docker build includes game assets. A prospective user therefore needs to verify asset requirements before assuming that the headless build can run.

Finally, the default-enabled updater and optional services add moving parts to deployment. The Makefile gives compile flags but no configuration schema for CoopNet hosting, Discord invites, update channels, or rollback. The README also does not document rollback, so version downgrade behavior is unconfirmed.

## Conclusion

sm64coopdx is appropriate for players who want a shared, synchronized Super Mario 64 world and for modders who need both Lua and C extension points. It is a poor fit for users seeking a turnkey launcher, documented licensing, or a build that automatically resolves every asset and platform requirement. Before adoption, verify the exact release workflow on the project website, confirm how your copy of the game is supplied, compile a headless build with the documented Docker command, and inspect the resulting networking and platform setup for your intended use.

## FAQ

### What is sm64coopdx?

sm64coopdx is an online multiplayer continuation of sm64ex-coop for the Super Mario 64 PC port. It synchronizes entities, enemies, events, and levels while exposing Lua and C extension points.

### How do I build sm64coopdx with Docker?

The checked-in `Dockerfile` documents building the `sm64coopdx` image and then running `make -j HEADLESS=1` with the repository mounted at `/sm64`. The repository does not list the resulting executable or launch procedure.

### Can sm64coopdx be modded with Lua?

Yes. The README says the project is moddable through Lua and directs users to `docs/lua/lua.md`. Native contributors are directed to `docs/c/c.md` for C documentation.

### Does sm64coopdx synchronize enemies and level events?

Yes. The README specifically says that all entities and every level are synchronized, including enemies and events, allowing multiple players to interact with the same world state.

### What license does sm64coopdx use?

The repository's license field is unknown. The README does not state licensing terms, so users must inspect the repository's license files and notices for a particular release.

## Sources

- [coop-deluxe/sm64coopdx on GitHub](https://github.com/coop-deluxe/sm64coopdx)
- [Issues](https://github.com/coop-deluxe/sm64coopdx/issues)
- [Project website](https://sm64coopdx.com)
- [README](https://github.com/coop-deluxe/sm64coopdx/blob/main/README.md)
- [Releases](https://github.com/coop-deluxe/sm64coopdx/releases)

---

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