LegacyShell WikiLegacyShell Wiki
Back to LegacyShell
Home
Wiki
Plugins
Docs
Back to LegacyShell
Home
Wiki
Plugins
Docs
  • Documentation

    • Getting Started

      • What is LegacyShell?
      • Speed Setup
      • Requirements
      • Installation
      • First Run
      • Config Files
      • Making an Account
      • Troubleshooting (Getting Started)
    • Running a Server

      • Architecture Overview
      • The Database
      • Users and Ranks
      • Adding Game Servers
      • Client Mirrors
      • Perpetual
      • Backups
      • Rate Limiting
      • Moderation
      • Closed Mode
      • Deployment
      • Troubleshooting (Running a Server)
      • Hosting for Someone Else's Instance
    • Content Creation

      • Maps
      • Dealing with Babylon Models
      • Map Blocks
      • Items and Skins
      • Hats and Stamps
      • Sounds
      • Gamemodes
      • Seasonal Events
    • Plugin Development

      • Quickstart
      • I Want To...
      • Anatomy of a Plugin
      • Lifecycle
      • Dependencies
      • Events (Concept)
      • Event Reference

        • services: events
        • game: events — shared logic (src/shell/)
        • game: events — main-thread server process
        • game: events — per-connection client object
        • game: events — room lifecycle & tick loop
        • game: events — in-browser gameplay
        • client: events — client server & build pipeline
      • Commands
      • Client-Side Code
      • Static Assets
      • Content Packs
      • Networking
      • Workers and State
      • Prediction and Authority
      • Recipes

        • Recipe: Killstreaks
        • Recipe: New Pickup Item
        • Recipe: New Gamemode
        • Recipe: Custom Weapon
        • Recipe: UI Modification
        • Recipe: Discord Integration
        • Recipe: Replacing Core Behaviour
        • Recipe: Persistent Plugin Storage
        • Recipe: Rewarding Players with Currency
        • Recipe: Custom Per-Player Data
        • Recipe: Custom Theme
      • Publishing
      • Pitfalls
      • Modifiers
      • Sound and Apollo
    • Codebase Reference

      • Repo Layout
      • Shared Shell Layer
      • Server-Only Markers
      • The ss Object
      • Build Pipeline
      • Stamps and Babylons
      • Game Loop
      • Rooms and Workers
      • Wire Protocol
      • Generated

        • Wire Protocol Opcodes
        • Enums & Lookup Tables
        • Database Schema
        • Config Reference
        • Slash Command Reference
      • Services Internals
      • Catalog and Items
      • Permissions Internals
      • Physics and Collision
      • Known Quirks
      • Codebase Anecdotes
      • Development Timeline
    • Contributing

      • Documentation Style Guide
      • Generators
      • For AI Agents

Publishing

Audience: Plugin authors · Prereqs: Anatomy, Lifecycle

Canonical source: src/shell/plugins.js (preloadPlugin's git-pull logic)

Sharing a plugin with other LegacyShell operators, and keeping it updated for them, is built directly on git - no separate package registry or plugin store.

Make your plugin folder its own git repository

cd plugins/yourplugin
git init
git add .
git commit -m "Initial commit"
git remote add origin <your repo url>
git push -u origin main

That's the entire "publishing" step. LegacyShell doesn't require anything special beyond a normal git repository - no manifest to submit anywhere, no build step, no approval process.

Installing it (what your users will do)

Anyone wanting your plugin clones it directly into their own plugins/ folder:

cd plugins
git clone <your repo url> yourplugin

The folder name they clone it into becomes the plugin's directory name on their system - doesn't have to match your repo's name, though matching it avoids confusion.

Auto-update is already built in

Once a plugin folder is a git repository, Lifecycle covers what happens next: every time the server hosting it restarts, LegacyShell runs git pull on that folder automatically. Pushing a new commit to your plugin's repo is the entire update mechanism from the plugin author's side - there's nothing else to do, and nothing your users need to do beyond restarting their server (which they're often already doing regularly if they're running Perpetual's scheduled restarts).

Keep this in mind when developing: don't push broken/incomplete commits to a branch your users are tracking - the next restart on their end pulls whatever's currently on that branch, with no review step in between.

Versioning

Bump PluginMeta.version yourself, on whatever scheme you like (semver is the convention every existing plugin uses) - nothing in LegacyShell enforces or reads this beyond displaying it in boot logs and in-game listings. legacyShellVersion is a separate, informational field - the LegacyShell build number (from /versionEnum.txt) your plugin was last verified against, shown to help a user judge compatibility before installing, but not itself checked or enforced anywhere in the loader.

Declaring dependencies for others

If your plugin needs npm packages or other plugins to function, see Dependencies - dependencies.js is what makes your plugin installable without the user having to manually chase down what it needs first.

Listing it publicly

The wiki's List of Plugins page is the community index of known LegacyShell plugins - it's just a markdown table, edited via a normal PR to the LegacyShell repository (see Contributing). Include your plugin's identifier, author, a short category/description, and either a link to its own documentation page (if you've written one under /wiki/plugins/Plugin Docs/) or its install/repo location.


This page was drafted with AI assistance and reviewed for accuracy. If something looks wrong, please open a PR or flag it.

Edit this page on GitHub
Next
Pitfalls