--- title: "I Built Campfire to Make Hosting Game Servers Less Work" author: "Douglas Maitelli" published: "2026-11-16T03:18:20.582Z" updated: "2026-11-16T04:21:04.505Z" url: "https://zyvop.com/i-built-campfire-to-make-hosting-game-servers-less-work-b9s67" canonical: "https://zyvop.com/i-built-campfire-to-make-hosting-game-servers-less-work-b9s67" tags: ["go","games","self-hosted","Homelab"] --- # I Built Campfire to Make Hosting Game Servers Less Work ![Cover image]() Running a game server is only part of the job. Someone needs to restart it when it gets stuck, change a configuration file, check why a mod failed to load, or restore a backup after something goes wrong. If friends help manage the server, they need a way to do those things without receiving SSH access to the machine underneath it. Game server panels already solve a lot of that. But after working with Pterodactyl and Pelican, I kept running into decisions that did not fit how I wanted to run things in my homelab. I wanted native OIDC authentication, updates that did not turn into plugin maintenance, and game hosts that could connect to the panel without exposing their own management endpoints or requiring me to maintain a separate HTTPS certificate on every node. That is why I built [Campfire](). ![Campfire overview showing resource usage, allocations, and game server status across connected hosts]() _One overview for game servers, resource allocations, and connected game hosts._ ## What I wanted to change Pterodactyl and Pelican are established projects, and they cover many of the things someone needs to host games. My issue was not that they could not run a game server. It was the extra work around running the panel itself. In the setups I used, OIDC was not a built-in option I could simply configure. I already have an identity provider for my homelab, and I wanted the game panel to use it rather than becoming another place to manage a separate login or maintain an authentication customization. Plugins and modifications introduced another maintenance task. Updating the panel could mean checking compatibility, reapplying changes, or waiting for an extension to catch up. A feature might work, but keeping it working became part of the upgrade procedure. I did not want signing in through my identity provider to depend on how carefully I preserved a modification across updates. The node networking model was another frustration. Having the panel or browser reach a management endpoint on each node meant arranging inbound access, DNS, firewall rules, and certificates for those endpoints. For nodes reached over the internet, that could mean exposing additional management ports online. Then there were the certificates themselves. Each node became another place where certificate issuance, renewal, deployment, and trust needed attention. None of those things is impossible to manage. I just did not want all of them to be prerequisites for adding another machine to run games. ## Let the game hosts connect to the panel Campfire separates the central panel from the agent that runs the games. The panel is called **Campfire**. The agent installed on each Linux game host is called **Spark**. One Spark can run several game servers, and one panel can manage several Sparks. The important networking decision is that Spark initiates an outbound connection to the panel's dedicated agent TLS listener. A Spark does not need an inbound management port. I do not need to publish a separate management URL for every game host just so the panel can control it. That does not mean game servers need no open ports. Players still need to reach the ports used by their games, whether directly, through a private network, or through whatever routing arrangement the deployment uses. Campfire separates that game traffic from the management connection. ![Campfire Sparks page showing connected game hosts and their resource allocations]() _Sparks connect back to the panel instead of exposing an inbound management service on every game host._ ## Fewer certificates to manage by hand Spark enrollment also avoids making each host another independently managed HTTPS server. From the panel, I create a Spark and generate its installation command. The command uses a short-lived, single-use enrollment token, installs the agent, and saves its enrolled identity on the host. Agent connections use client certificates. For the generated panel certificates, the enrollment helper handles the trust setup. Custom private certificate authorities may still require a CA file on the host. There is still TLS to operate. The browser-facing panel needs HTTPS, and Sparks need to reach and trust the panel's agent listener. Expired agent identities need re-enrollment. The difference is that I am not setting up a publicly reachable HTTPS management endpoint and a separate certificate renewal workflow on every game node. That was the part I wanted to remove, not encryption or authentication. ## Authentication should be part of the application Campfire supports local password accounts and optional OpenID Connect directly. OIDC is configuration, not a patch I need to reapply after updating the panel. That distinction matters to me. A feature being technically possible through an extension is not the same as the application taking responsibility for it as part of its normal release and upgrade process. ![Campfire sign-in page with OpenID Connect authentication]() _OIDC is built into the authentication flow rather than added as a panel modification._ Access inside the panel is separate from signing in. Campfire combines platform roles with server ownership and memberships, so someone can manage a particular game without administering the whole installation. A friend might need console access and permission to restart a server, but not permission to restore backups or edit files. Someone helping maintain the game might need broader access without receiving access to unrelated servers. Scoped, expiring personal API tokens support automation. Campfire also offers an optional SFTP gateway for browsing and transferring game files with a desktop client. It authenticates with those personal API tokens and enforces the same server permissions, rather than introducing a separate set of filesystem accounts. ## Keep game-specific knowledge in definitions Different games need different installation commands, startup arguments, configuration fields, and save locations. Campfire keeps that knowledge in reusable definitions called **Embers**. An Ember describes how to install, configure, and run a game. Multiple servers can share the definition while keeping their own settings, files, ports, and resource allocations. Campfire can import native Embers or convert supported Pterodactyl and Pelican Eggs. Imports include a preview and conversion warnings; I do not want to imply that every existing Egg can be translated without changes. Definition updates are explicit as well. I can review and apply an update instead of having an upstream change silently alter an existing server's behavior. I am not trying to eliminate every manual decision. Reviewing a change to how a game runs is useful intervention. Repairing a panel customization after an unrelated update is the kind I wanted less of. ## Make the everyday work easier Once the host is connected, the normal game server work should happen in the browser. Campfire includes installation and lifecycle controls, live console output, command input, resource history, a file browser, and a text editor. Files can be uploaded, downloaded, compressed, and extracted without opening a shell on the host. ![Campfire server console showing live game output, command input, and server details]() _Console output and server controls sit together, without requiring host access._ ![Campfire file browser showing game server files and folders]() _Browse and manage game files directly from the panel, without opening a shell on the host._ Embers can also recognize specific console errors and retain them under **Needs attention**, with guidance and links to the relevant file or server settings. That does not replace reading logs. It gives useful game-specific troubleshooting knowledge somewhere to live, instead of making someone rediscover the same problem every time it appears. Sparks can be updated remotely from the panel. Servers can also be copied or transferred between hosts, with background jobs, progress tracking, retry, and cancellation. ## Backups are part of the workflow Sometimes I want a complete server backup. Other times, I only need the world or save files. Campfire supports both full-server backups and Ember-defined save-data backups. Snapshots can be named and pinned, with per-server retention and optional S3-compatible off-host storage. Schedules support one-time and recurring actions, including an optional stop, backup, and start sequence when taking a backup with the game stopped is more appropriate. ![Campfire server backups page showing snapshots and backup controls]() _Full-server and save-data backups are managed alongside the server's other operations._ Portable backups can also be uploaded to recover a server or its save data. A game snapshot is not a backup of the entire installation, though. The panel database, private identities, Spark state, and game data still need an installation-level backup and recovery plan. ## Connecting the game to the people playing it Knowing that a container is running is not the same as knowing what is happening inside the game. I wanted Campfire to support both. Infrastructure state tells me whether a server is running and how many resources it uses. Game state can tell the people playing it who is online, which world is loaded, or whether something worth sharing just happened. Game integrations let a compatible mod or adapter publish current state and events through Spark. Current state includes things like player count, capacity, and custom fields. Events are individual occurrences that belong in the server's history, such as a player joining or a boss being defeated. Events can also carry screenshots and clips when the publisher provides them. > **Example: Trying it with Valheim** > > I have been experimenting with this through a [server-side Valheim mod](). > > It runs as a BepInEx plugin on the dedicated server, so players can use an unmodified Valheim client. The mod reports the connected player count and online player names every 15 seconds, along with the server capacity, world name, and crossplay invite code when available. > > It also publishes player joins, departures, deaths, and first boss defeats. Boss announcements follow world progression, so killing the same boss again does not generate another first-defeat notification. > > That gives me a practical way to test the integration model against an actual game rather than only designing an API around hypothetical events. > > This is a separate, optional game mod, not a modification to the Campfire panel. Campfire provides the integration support; the mod supplies the Valheim-specific knowledge. ### Follow what happens in Activity The server's **Activity** tab brings together operations, jobs, game events, console alerts, and notification outcomes. It gives me one place to follow what happened to the server and what happened inside the game. I can inspect a retained game event and its attached media alongside administrative actions, rather than having to reconstruct the history from console output. ![Campfire server Activity view showing retained events and filtering controls]() _The Activity tab keeps server operations and game events available for inspection inside Campfire._ ### Put useful information in Discord From there, I can choose which events to share with the people playing through Discord. Campfire's Discord integration has two jobs: send notifications about things that happen, and maintain a live card describing the server's current state. The card includes the server name, runtime status, and connection address when available. I can choose additional fields such as player count, capacity, world name, invite code, or the online player list reported by the Valheim mod. ![Campfire's Discord server-card preview showing runtime status, connection address, player count, capacity, and a join code]() _An example card in Campfire's built-in preview, using demonstration data. This is a preview of the message published to Discord, not a screenshot of the Discord application or a live Valheim server._ Campfire updates the existing card instead of posting a new status message every time a value changes. When game observations expire, selected values become unavailable rather than continuing to show an old player list as if it were current. Notifications can be routed to multiple destinations with their own categories and game-event filters. I can keep backup and operational messages in an administrator channel while sending selected game events to the people playing. Event filters can also match specific fields, so enabling game notifications does not have to mean forwarding everything a mod publishes. Screenshots and clips attached to matching game events can be uploaded to Discord too. Apprise is available separately for operational monitoring notifications. The Discord integration is where the game-specific event routing and live server cards live. Delivery outcomes are recorded back in **Activity**, so I can check whether a notification actually reached its destination rather than assuming that creating an event meant someone received it. These features need a compatible publisher. Campfire does not automatically understand every game's player list or events. The Valheim experiment is one example of how a game can supply that information without teaching the panel itself how every game works. ## Running it yourself Campfire can run in Docker or as a Linux binary. The production binary includes the web interface, and the panel supports SQLite or PostgreSQL. Spark runs on Linux and requires rootful Docker Engine. The panel and Spark can share a machine, so starting with one host does not require a separate management server. The [documentation]() covers deployment, enrollment, authentication, backups, and recovery. ## Why I built another game server panel I did not build Campfire because game server panels were missing. I built it because I wanted different defaults: native OIDC, an outbound agent connection, less per-node certificate administration, and core features that do not depend on maintaining panel modifications across updates. There is still infrastructure to operate. Games still need resources, players still need network access, and backups still need to be tested. Campfire does not remove those responsibilities. It is an attempt to make running the management layer less of a separate project, so more of the work can stay focused on the games themselves. The project is still evolving. Feedback is welcome, especially from people using Pterodactyl or Pelican who have run into similar maintenance and networking tradeoffs. You can find the project here: - [Campfire on GitHub]() - [Documentation]() Thanks for reading ;)