# netfox adds rollback netcode to Godot projects

> netfox is a set of Godot 4 addons providing consistent timing across machines, client-server architecture, interpolation, lag compensation with client-side prediction and server-side reconciliation, and noray connectivity. It suits Godot developers who need responsive multiplayer, and it is an addon rather than an engine change.

**foxssake/netfox** — Addons for building multiplayer games with Godot

- Repository: https://github.com/foxssake/netfox
- Website: https://foxssake.github.io/netfox/
- Stars: 1,118 · Forks: 91
- Language: GDScript
- License: MIT
- Published: 2026-10-19 · Updated: 2026-10-19 · Language: en
- Canonical page: https://hysenlabs.com/projects/foxssake-netfox

## Four addons, and only one of them is the core

netfox is a set of addons for responsive online games with the Godot engine, and the package is split into four pieces with a clear entry point.

The netfox addon is the core package. It implements timing, rollback and other multiplayer features, and the README marks it as the place to start. The netfox.noray addon implements noray integration to establish a connection between players, and is described as useful for online games. The netfox.extras addon provides high-level, game-specific, convenience features built on top of netfox, like base classes for input management or weapons, and the README suggests checking it for reusable components for your game. The netfox.internals addon holds shared utilities for the other addons and is included as a dependency, with no need to install it separately.

That structure is the design. The core knows about timing, rollback and reconciliation, and knows nothing about your game. The extras layer knows about input management and weapons, which are game-shaped concepts, and it is the layer you would fork or replace for your own genre.

The feature list at the top of the README is the capability summary: consistent timing across multiple machines, support for client-server architecture, smooth motion with easy-to-use interpolation, lag compensation with client-side prediction and server-side reconciliation, and what the README calls bullet-proof connectivity with noray integration.

The primary language is GDScript, and the licence is MIT with a LICENSE file in the repository. The project is documented at foxssake.github.io/netfox, and there is a Discord server and a ko-fi support link.

## Installation is a copy of addons, and forgetting to enable them breaks the build

There are three ways to get netfox into a project, and the third is what most people use when reading documentation.

Releases are the primary route. You find the latest netfox under the repository Releases page, and each release contains the addons plus a build of Forest Brawl for Windows and Linux. Each addon has its dependencies packed with it, so netfox.extras.vx.y.z.zip also contains both netfox and netfox.internals. For releases before v1.1.1 there was a separate .with-deps.zip variant containing the addon and its dependencies, while the regular zips contained only the addon itself, which is a detail that will matter if you are unpacking an old archive and finding a missing dependency.

The Asset Library route is the second. The README says to search for the addon name in Godot's AssetLib or download from the site, and gives the Godot asset library entries for netfox, netfox.noray and netfox.extras as assets 2375, 2376 and 2377.

The third is source. You download the source and copy the addons of your choice to your Godot project.

Then there is the step that catches people out. After adding netfox to your project, you have to enable the addons in your project settings. Otherwise, Godot will present you with errors about undeclared identifiers. That is a straightforward instruction and it is the single most common support issue in a project distributed as Godot addons, because the symptom, undeclared identifiers, does not obviously point at an addon that was never enabled.

The repository reflects a working Godot project rather than a bare addon folder. There is a project.godot file, an addons/ directory, an examples/ tree with many separate sample projects, a docs/ directory, a mkdocs.yml for the documentation site, a default_env.tres, a script_templates/ directory, a sh/ directory for shell helpers, a test/ directory, and an export_presets.cfg.

## The examples are the actual API documentation

netfox ships a large set of example projects, and reading them is the fastest way to understand what the library expects from your game.

The examples/ directory contains a comparison sample with a single player version at examples/single-player, a simple example at examples/multiplayer-simple and an example using netfox at examples/multiplayer-netfox. The README explains the purpose: a simple demo was implemented as a single-player game and then ported to multiplayer using both a naive approach and netfox, so that you can see how the two compare and how netfox fares against Godot's built-in multiplayer tools.

The feature examples are more directly useful. There is input-gathering, multiplayer-state-machine, multiplayer-fps, rollback-debugger, property-configuration, input-prediction, rollback-npc, state-synchronizer-npc and visibility-filtering, plus shared/ and snippets/ directories.

The names reveal the concepts the library works with. Rollback, prediction, state synchronisation, visibility filtering and property configuration are the names of the problems netfox solves, and having a dedicated example for each means you can copy the pattern rather than derive it.

Two of them are worth calling out. The rollback-debugger example exists because rollback netcode is hard to debug, since the game state is being rewound and replayed, and a tool for inspecting that process is a sign the author has actually shipped this. The visibility-filtering example is about bandwidth: not every object needs to be replicated to every client, and the example shows how that is expressed.

Two full games are included as well. Forest Brawl is a party game where an arbitrary amount of players compete by trying to knock each other off of the map, created specifically to demonstrate netfox usage in an actual game. The README also points to Godot Rocket League as a demonstration of netfox's physics rollback capabilities for smooth and responsive physics-based gameplay.

## noray handles peer discovery, and the free instance is not for shipping

The connectivity story runs through noray, and the README is specific about the boundary between the hosted instance and production.

netfox.noray implements noray integration to establish a connection between players, and the feature list describes the result as bullet-proof connectivity with noray integration. The problem it solves is the one every indie multiplayer game has: the players are behind different NATs, and without a rendezvous and relay service they simply cannot find each other.

For prototyping, a free to use noray instance is hosted at tomfol.io:8890, the same instance used by Forest Brawl. The README says you can use it to quickly test your games online, but that it is not recommended for shipping games, because the instance has configured limits and no uptime guarantees are made.

That caveat is the important part for an adopter. A free relay instance is a reasonable way to develop against, and a bad idea to depend on, because a game whose matchmaking goes down because someone else's server stopped is a support burden that has nothing to do with your code.

For production there is a hosted option, and the README describes the partnership. Edgegap has partnered with netfox, offering game hosting, matchmaking and more, with links to their orchestration hosting, matchmaker and game server hosting pages, plus an official netfox Forest Brawl guide to get started. There is also a ko-fi support link for the project itself.

The C# support is explicitly experimental and lives in a separate repository, Netfox Sharp, with its own guide. That split is sensible, since a C# implementation of the same netcode model has to solve the same problems in a different language.

## Games made with netfox are listed on the project site

The README has a section on games built with netfox, pointing to a Made with netfox page on the documentation site, and it shows five titles with Steam links: Bubble Battle, PL4no-B, Chrome Carnage, Nitro Turtles and Kick and Hide.

The presence of shipped games is the strongest evidence available for whether a netcode library works in production, because a rollback implementation either feels right or it does not, and players notice immediately. A library that has produced five released games has survived that test more than once.

It is also the best way to calibrate expectations. These are small team projects, a party game and several arcade ideas, not a competitive shooter with a large player base. That is a fair sample of the audience for a Godot addon set, and it tells you the scale of project the library is aimed at.

For anyone evaluating netfox, the practical sequence is to look at the games list, then open the Forest Brawl build that ships with each release, since it is a complete working project rather than a fragment, and then read the feature examples for the specific mechanism you need. The documentation site at foxssake.github.io/netfox carries the same material in a searchable form, and the requirements.txt at the repository root lists mkdocs, mkdocs-puml and pymdown-extensions, which are the tools the documentation and its diagrams are built with.

## MIT licensed, version 1.35.3, and a Godot 4.x floor

The licence is MIT, with the LICENSE file in the repository as the authoritative text, and this is a licensing statement rather than legal advice.

The version record shows an interesting gap in the numbering. Recent releases are v1.35.3 from 2025-11-23, v1.25.3 from 2025-03-27 and v1.19.1 from 2024-12-29. The minor version is not sequential in the way a library's usually is, which suggests the minor number tracks something other than a sequence, most likely a Godot or feature generation. Anyone reading a version number should treat it as an identifier rather than an order.

The last push to the repository was on 2026-09-26, and the repository is not archived, so work is continuing even though the most recent tagged release is from November 2025.

On Godot versions the README is precise. Godot 4.x is supported by netfox, and the README asks you to open an issue if you find any issue using any supported version. Forest Brawl and the other examples are written against Godot 4.1, and they may or may not work when opened with any other version. That is a fair warning to read before copying an example into a project on a different point release.

There is also an upgrade guide at docs/upgrading.md, and the README points you to it if you are upgrading from an older version of netfox. For a library that has been through version 1.35, an upgrade path document is a real deliverable rather than a courtesy, and its presence is a good sign about how the project handles breaking changes.

The project is maintained by a single author as far as the repository shows, with a Discord server, a ko-fi page and a sponsorship link, and the documentation site also has a giscus.json, which is the configuration for GitHub Discussions comments embedded in the docs. That is a small detail, and it tells you where the author wants the conversation to happen.

## Conclusion

Adopt netfox if you build multiplayer games in Godot 4 and want rollback, prediction and reconciliation without writing the netcode layer yourself. Do not adopt it if your project is on Godot 3, since the README states Godot 4.x is supported, and do not expect it to carry the networking for you, because the examples show it expects you to structure your game state around its model. Before you start, copy the addons into your project and enable them in project settings, otherwise Godot will report undeclared identifiers, and read the upgrade guide if you are moving from an older netfox version.

## FAQ

### How do I install netfox in a Godot project?

Download the latest release from the repository Releases page, or get the addons from Godot's Asset Library, or copy them from the source. Each addon zip has its dependencies packed in, so netfox.extras also contains netfox and netfox.internals. After copying, you must enable the addons in your project settings, otherwise Godot reports undeclared identifiers.

### Which Godot versions does netfox support?

The README states that Godot 4.x is supported by netfox and asks you to open an issue if you find any problem on a supported version. Forest Brawl and the other examples are written against Godot 4.1 and may not work with other versions.

### What is the difference between the netfox, netfox.extras, netfox.noray and netfox.internals addons?

netfox is the core package implementing timing, rollback and other multiplayer features, and the README says to start there. netfox.extras provides high-level, game-specific convenience features such as base classes for input management or weapons. netfox.noray implements noray integration for connecting players, and netfox.internals holds shared utilities and comes as a dependency.

### Can I use the free noray instance for a released game?

No. The README says a free to use instance is hosted at tomfol.io:8890 for prototyping and quick testing, but that it is not recommended for shipping games because the instance has configured limits and no uptime guarantees are made.

### Does netfox support C#?

There is experimental C# support, in the separate Netfox Sharp repository with its own guide, rather than in the GDScript addons. The main netfox addons are written in GDScript for Godot 4.x.

## Sources

- [foxssake/netfox on GitHub](https://github.com/foxssake/netfox)
- [License: MIT](https://github.com/foxssake/netfox/blob/main/LICENSE)
- [Project website](https://foxssake.github.io/netfox/)
- [README](https://github.com/foxssake/netfox/blob/main/README.md)
- [Releases](https://github.com/foxssake/netfox/releases)

---

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