panel is a free, open source gaming project written in TypeScript and released under MIT. It has 755 GitHub stars, 62 forks and 12 open issues, and was last pushed 7 hours ago. On this registry it ranks #47 of 48 tracked projects in Gaming, with 5 head-to-head comparisons available.

What is panel?

Calagopus Panel is a self-hosted game server management panel for Minecraft, Rust, and similar titles, rewritten from the ground up in Rust as a modern alternative to Pterodactyl and Pelican.

What it is

Calagopus Panel is a container-based game server management panel whose backend is built on Rust with Tokio and Axum, paired with a frontend built from React, Mantine, and Tailwind. The repository is organised into frontend/, backend/, database/, database-migrator/, shared/, wings-api/, and several extension trees, and it is released under the MIT licence. Development is tracked publicly through separate frontend and backend roadmaps, and community support runs through a Discord server and Crowdin translation project.

The concrete problem it addresses is that operators of Pterodactyl or Pelican installations are tied to an older stack they wish to replace without abandoning their existing configuration. Calagopus reuses Pterodactyl-style eggs — including a Rust port of Laravel's validation rules in the rule-validator/ crate — so existing server definitions carry over, and it provides a supported migration path for importing a setup from Pterodactyl or Pelican. It aims to deliver the same secure, container-based server management with better performance, a refreshed interface, and a cleaner extension model on both the frontend and backend.

Key capabilities

  • Backend built on Tokio and Axum in Rust, with an auto-generated Rust API client for the Wings API produced by a TypeScript generator in wings-api/generator-src/.
  • Frontend composed of React, Mantine, and Tailwind, with a responsive dashboard interface.
  • Extension systems on both sides: frontend extensions live in frontend/extensions/ (themes and plugins), backend extensions in backend-extensions/ (auth providers and database drivers), described as real plugin APIs rather than patched overrides.
  • Compatibility with Pterodactyl-style eggs, supported by rule-validator/, a semi-port of Laravel's validation rules written in Rust.
  • Documented import paths for existing Pterodactyl and Pelican installations.
  • Database schema management through Drizzle migrations in database/, with a separate Rust and SQLx tool in database-migrator/ to run them.
  • A schema extension system with a core library in schema-extension/core/ and a proc macro for deriving schema extensions in schema-extension/derive/.

Who uses it and how

  • Self-hosting operators running Docker-based game servers, as indicated by the project's self-hosting and docker topics.
  • Existing Pterodactyl or Pelican administrators who migrate an established installation rather than starting from scratch.
  • Hosts of Minecraft and Rust game servers, the two titles explicitly called out by the project's topics and description.
  • Developers building themes, plugins, auth providers, or database drivers as frontend and backend extensions.
  • Contributors working across a Rust backend, a TypeScript-adjacent frontend toolchain, and a public roadmap, following the guidelines in CONTRIBUTING.md.

Getting started

Full installation instructions live in the documentation at calagopus.com/docs/panel/installation, which is the canonical reference for standing the panel up; the README itself does not publish a package name or compose file.

How it compares

Among the tools named in its own documentation — Pterodactyl Panel and Pelican Panel — Calagopus positions itself as the Rust reimplementation of Pterodactyl's container-based model, retaining egg compatibility and offering explicit migration routes from both projects while supplying its own extension APIs. It is MIT-licensed and self-hosted, so operators keep their servers and data on their own infrastructure rather than on a hosted service.

When to use it — and when not

A self-hoster must operate Docker, a database with migrations managed through Drizzle and the database-migrator/ tool, and the Wings daemon that the panel communicates with via its generated API client. It is a good fit for operators already in the Pterodactyl or Pelican ecosystem who want a Rust backend and are comfortable following externally hosted documentation and roadmaps; it is a poor fit for anyone wanting a turnkey paid host or a panel whose full design lives in the repository itself, since key detail here is deferred to calagopus.com and third-party notes. As a ground-up rewrite, the project is still working toward its stated aims rather than promising them, with 12 open issues at the time of listing.

project readme (upstream, from github) — read inline

Calagopus Logo

Calagopus Panel

Rust License GitHub issues GitHub stars Discord Crowdin

A modern game server management panel, rebuilt from the ground up in Rust.

Calagopus is a ground-up reimplementation of Pterodactyl Panel in Rust. It keeps what made the original great - secure, container-based game server management - while aiming for better performance, a refreshed UI, more features, and a cleaner extension model on both the frontend and backend. If you already run Pterodactyl or Pelican, there is a supported migration path.

Calagopus dashboard

Features

  • Rust backend - a fast, efficient backend built on Tokio and Axum.
  • Modern frontend - React, Mantine, and Tailwind for a clean, responsive UI.
  • Extensible by design - first-class extension systems for backend and frontend, no hacky patches or overrides, real plugin APIs.
  • Egg compatible - reuses Pterodactyl-style eggs, including a Rust port of Laravel's validation rules.
  • Migration friendly - import your existing setup from Pterodactyl or Pelican.

Installation

Full instructions live in the documentation.

Roadmap

Tracked publicly here:

Project Structure

Repository layout
  • frontend/ - The frontend of the panel, built with React, Mantine, and Tailwind.
    • extensions/* - Frontend extensions, such as themes and plugins.
  • backend/ - The backend of the panel, built with Rust and Axum.
  • backend-extensions/* - Backend extensions, such as auth providers and database drivers.
  • database/ - Database migrations using Drizzle.
  • database-migrator/ - A tool to run database migrations, built with Rust and SQLx.
  • shared/ - Shared code between backend parts, mainly relevant for extensions.
  • wings-api/ - An auto-generated API client for the Wings API, built with Rust.
    • generator-src/ - The source for the API generator, written in TypeScript.
  • rule-validator/ - A semi-port of Laravel's validation rules in Rust for use with eggs.
  • schema-extension/
    • core/ - Core library for the schema extension system.
    • derive/ - A proc macro to derive schema extensions.

Contributing

Contributions are welcome. See CONTRIBUTING.md for PR guidelines, open an issue to discuss larger changes first, and check the Discord if you want to chat through an idea before writing code.

Acknowledgments

Calagopus builds on the ideas and ecosystem of Pterodactyl and Pelican. Thanks to those projects and their communities.

License

See LICENSE.

Star History

Star History Chart

Frequently asked questions

Is panel free to use?

panel is open source under the MIT licence. There is no licence fee and no seat count — you can self-host it or, where the project offers one, pay a vendor for a managed version instead.

What does panel do?

A modern game server management panel built in Rust. Deploy, monitor, and manage Minecraft, Rust, and other game servers with industry-leading performance.

What is panel written in?

panel is primarily written in TypeScript. Its source is publicly available at https://github.com/calagopus/panel, and it has 755 GitHub stars.