MossWing

Run Windows-native game servers from the free panel you already use.

MossWing is a Windows-native daemon that speaks the Pterodactyl / Pelican Wings protocol. Point your existing panel at a MossWing node and it manages native Windows game servers — the kind that ship a Windows-only .exe and break (or lose anti-cheat) under Wine/Proton: V Rising, Enshrouded, Space Engineers, ARK: Survival Ascended, Palworld, and more.

It is free and open source (MIT). Another love letter to gamers. 🌿

The honest pitch

Not "seamless containers." On Windows, the games that need this often can't run in a container — GUI/Direct3D binaries, and kernel anti-cheat (EAC, BattlEye) that deliberately refuses to run in a VM. So MossWing doesn't pretend:

Native supervised game-server processes with resource limits, managed from the panel you already use.

Each server is a real Windows process tree governed by a Job Object — a memory ceiling, an optional CPU cap, a process cap, kill-the-whole-tree-on-teardown, and a live stats feed — with no container runtime, no multi-gigabyte images, and no Windows Server licensing tax.

How it works

The panel is a control plane: it identifies a node by token and talks a fixed REST

• WebSocket contract. It never touches Docker — that lives entirely inside the daemon. So MossWing reuses the entire panel-facing half of Wings and rebuilds exactly one thing: the execution backend.

panel  ──Wings protocol (MIT)──►  MossWing daemon
                                   ├── panel-facing layer   reuse from Wings
                                   └── ProcessEnvironment    Job Objects + CreateProcess

See docs/architecture.md and docs/process-environment.md.

Eggs

MossWing uses the Pterodactyl/Pelican egg format — a Windows-native variant — so existing egg authors find it familiar. An egg is the per-game definition that installs and runs a server, with the same meta / startup / config / variables surface you already know. The Docker-specific fields are reinterpreted for native Windows rather than renamed: docker_images become runtime references, scripts.installation.entrypoint selects a PowerShell/cmd interpreter, and config.stop gains Windows stop directives. See spec/egg.

Status

This is an early, building-in-the-open scaffold. What works today is green and proven; the daemon wiring is next.

• pkg/winjob — Win32 Job Object supervision (mem/CPU/process caps, kill-on-close, stats). Pure stdlib, no deps.
• internal/environment/windows — the 21-method Wings ProcessEnvironment, native Windows backend. Compile-time conformance-checked.
• spec/egg — the egg format (Pterodactyl/Pelican convention, Windows-native variant), validation, Windows stop directives, V Rising example.
• Daemon skeleton — config + token auth + panel-facing HTTP API (/api/system, /api/servers, power, commands) routing into the Windows environment. Proven end-to-end over HTTP.
• Console WebSocket, panel config sync (/api/remote), and SFTP.
• Egg installer: run PowerShell install scripts in a staging dir; config-file templating.
• A starter egg library for the priority Windows-only titles.

Quickstart (see the supervision core work)

Requires Go 1.26+ on Windows.

# build + test everything
go build ./...
go test ./...

# watch MossWing supervise a real process: stream its console, sample live
# stats from the Job Object, and tear the tree down on Ctrl+C
go run ./cmd/mosswing-demo -mem 128
go run ./cmd/mosswing-demo -mem 512 -cpu 50 -- ping -n 20 127.0.0.1

Example output:

[server] Reply from 127.0.0.1: bytes=32 time<1ms TTL=128
[stats] procs=2 cpu=0.3% peakMem=8.4MiB cpuTime=31ms io(r/w)=0B/0B
[mosswing] server exited cleanly.

That [stats] line is the whole thesis: a resource-limited, fully-supervised native Windows process emitting panel-shaped telemetry — no Docker.

Layout

cmd/mosswing/          the daemon: config + auth + panel-facing HTTP API
cmd/mosswing-demo/     runnable proof of supervision + stats
pkg/winjob/            Win32 Job Object supervision core
internal/environment/  the Wings ProcessEnvironment contract (mirrored) + Windows backend
internal/api/          panel-facing HTTP routes (token auth, power, commands, system)
internal/server/       server registry + power-action dispatch
internal/config/       node config + token auth
internal/remote/       client for the panel's /api/remote API
internal/events/       minimal pub/sub bus (mirrors wings/events)
spec/egg/              the egg format: structs, schema, validation, examples
docs/                  architecture + process-environment design

License

MIT. MossWing reuses the MIT-licensed Wings protocol and is not affiliated with or endorsed by the Pterodactyl or Pelican projects.