SpectraEvents

One engine. Any event.

SpectraEvents is a modular, data-driven event engine for Minecraft servers, designed to power interactive and cinematic server events without locking the server into a single event type.

Instead of creating a separate plugin for every Meteor, Airdrop, Metin, Piñata, Vault, or Boss event, SpectraEvents provides a reusable runtime that these events can be built on top of.

The project focuses on clean architecture, native Minecraft rendering, performance, extensibility, and giving server owners a foundation capable of supporting both simple events and large multi-stage experiences.

SpectraEvents is currently in active development.

What can SpectraEvents power?

SpectraEvents is being designed for events such as:

• Meteors that fall from the sky, unlock after a countdown, take damage, and reward participating players
• Airdrops that descend into the world and can be claimed after unlocking
• Metins with health stages, combat phases, contribution tracking, and boss encounters
• Piñatas based on hit counters instead of traditional health
• Multi-stage vault events with interaction and progression mechanics
• Boss portals requiring activation, charging, boss encounters, and rewards
• Custom events created from reusable engine primitives

The goal is not to hardcode these event types into the engine.

They are reference implementations demonstrating what can be created with the same underlying systems.

Native 3D models

SpectraEvents uses Minecraft's native display entities rather than requiring a mandatory external model engine.

The model runtime supports multi-part models built from display entities with independent:

• Position
• Rotation
• Scale
• Local transforms
• Interaction hitboxes
• Persistent ownership metadata

This architecture is being built with future support for custom resource-pack models and external model/item providers in mind.

Event lifecycle and phases

Every event instance has a strict lifecycle and its own configurable phase progression.

For example:

Meteor

FALLING
   ↓
IMPACT
   ↓
LOCKED
   ↓
ACTIVE
   ↓
DESTROYED
   ↓
COMPLETED

Another event can use completely different behavior:

Airdrop

FALLING
   ↓
LOCKED
   ↓
OPEN
   ↓
CLAIMED
   ↓
COMPLETED

The global event lifecycle and event-specific phases remain separate, allowing SpectraEvents to support many different event structures without turning the engine into one giant hardcoded state machine.

Built for reusable mechanics

SpectraEvents is being built around reusable gameplay primitives discovered from real event implementations.

Current foundations include:

• Event lifecycle
• Phase transitions
• Temporal scheduling
• Multi-part model rendering
• Player interaction routing
• Health
• Atomic claim handling
• Platform resource ownership
• Deterministic cleanup

Future systems are planned around real use cases rather than speculative abstractions.

Planned areas include:

• Conditions
• Triggers
• Actions
• Rewards
• Loot
• Participant tracking
• Leaderboards
• Event areas
• Mob waves
• Boss encounters
• Animations
• Persistence
• Restart recovery

Data-driven event authoring

A major goal of SpectraEvents is allowing server owners to create events without writing Java code.

The planned configuration pipeline is:

YAML
 ↓
Parse
 ↓
Validate
 ↓
Compile
 ↓
Immutable runtime definition

Invalid configurations should produce useful validation errors instead of failing unpredictably while the server is running.

Event definitions are also designed with safe reloads and version-aware runtime behavior in mind.

Performance-focused

SpectraEvents is designed for production servers.

The architecture avoids unnecessary global tick loops and keeps platform-specific work isolated from the core event engine.

Scheduling and world operations are designed around modern Paper APIs, with future Folia compatibility considered as part of the platform architecture.

Temporary entities, scheduled tasks, interaction delegates, and runtime resources are explicitly owned and cleaned up when an event completes or is cancelled.

Clean architecture

SpectraEvents separates the engine from Minecraft-specific implementation details.

Core
 ↓
Application
 ↓
Platform Adapter
 ↓
Paper

The core runtime does not depend on Bukkit or Paper.

This makes the engine easier to test and allows additional server-platform adapters to be developed in the future without rewriting the domain logic.

Current platform

The current primary target is:

• Paper 26.2
• Java 25

Support for additional Minecraft versions and server platforms is planned after the main event engine reaches a stable state.

Development status

SpectraEvents is still under active development.

The current development builds are primarily intended for testing the engine architecture and reference event implementations rather than production deployment.

The first reference events being used to validate the engine are:

• Meteor
• Airdrop
• Metin

Once the engine primitives and configuration format stabilize, these will become complete examples for building custom events.

Planned ecosystem

Future versions are intended to include optional integrations such as:

• PlaceholderAPI
• WorldGuard
• Oraxen
• Nexo
• ItemsAdder
• Database-backed persistence
• Developer API and addon support

These integrations will remain optional wherever possible.

Open architecture, serious foundation

SpectraEvents is intended to become more than a collection of scripted Minecraft events.

The goal is to provide server owners and developers with a professional event framework capable of powering anything from a small timed loot drop to a large cinematic server-wide event involving models, combat, progression, bosses, leaderboards, rewards, and persistent state.

Build the event. Let SpectraEvents run it.