English
Español
Català
Understand the foundation
- What Serenity is and why it exists
- How systems are organized and interact with each other
The Unity infrastructure you keep rebuilding, already solved.
Menus, modals, themes, localization, audio, settings, events and a clean startup pipeline. Import it into your project and start building the game instead.
Serenity Game Systems Foundation
- Drop-in systems for menus, modals, themes and view navigation
- Audio buses, settings persistence and localization wired up out of the box
- Typed event dispatcher and ordered initialization, no static singletons
Try Serenity right here in your browser
Jump into the live demo and play with the menus, themes and UI systems for yourself. There's nothing to download and nothing to install.
How to play
Most modern game controllers work straight away in the browser. Plug one in before you start, or just use your keyboard and mouse.
Mouse
- Focus element Navigation
- Left mouse button Submit
Keyboard
- WASD Navigation
- Enter Submit
- P Pause
Gamepad
- D-pad Navigation
- South button Submit
- Start button Pause
Same buttons, different names
- ✕ PlayStation A Xbox B Nintendo
- PlayStation Xbox + Nintendo
It only loads when you click, so the first start can take a few seconds.
The demo works best on a desktop browser.
Open the demo in a new tabWhy Serenity exists
Because scaling Unity projects shouldn’t feel like starting over every time.
The Problem
The Solution
The Problem
Your Unity project starts simple… then becomes unmanageable.
The Solution
A clean architecture that actually holds as your project grows.
The Problem
Everything ends up tangled inside MonoBehaviours.
The Solution
Build systems once, reuse them across all your projects.
The Problem
You keep rebuilding the same systems again and again.
The Solution
Clear boundaries between game logic, application, and Unity.
The Problem
Your team loses consistency as the project grows.
The Solution
A solid foundation your whole team can rely on.
Explore Serenity systems
More than thirty reusable Unity systems documented one by one: what they solve, how they fit together and when to use them.
Core
- Event Dispatcher Typed signals dispatched through a service, with auto-registration support and no static singletons.
- Input System Integration A player input gateway that routes Unity Input System actions to menus, gameplay and UI navigation through clean services.
- Initialization Pipeline An ordered async pipeline that runs your Unity startup tasks with criticality levels, weighted progress and telemetry streaming to any loading screen.
- Structured Logging System A category-aware, severity-filtered logging service that routes structured entries to console and file outputs through clean, Unity-free domain interfaces.
- Game Timer System A named timer registry that centralizes per-frame ticking, lets each timer choose scaled or unscaled time, and keeps game session, pause and cutscene timing in one place.
Configuration
- Game Settings Typed get and set use cases for bool, int, float and string settings, with persistence and update signals built in.
- Hardware and System Configuration A layered service that captures a point-in-time hardware and OS snapshot at boot and exposes it to adaptive quality, analytics and crash reporting.
- Graphics Settings System A graphics service that persists quality level, resolution and fullscreen state through Game Settings and broadcasts every change via the Event Dispatcher.
- Data Persistence Layer A port hierarchy that decouples save contracts from Unity backends so file storage, PlayerPrefs and encryption can all change without touching game code.
- Asset Prefetcher A runtime Addressables memory cache with a configurable byte budget and LRU eviction, prewarmed by label at boot and inspectable live through a runtime Cache Inspector.
User Interface
- Menu System Declarative menus, shared UI themes and predictable navigation, configured as assets instead of hand-wired GameObjects.
- Modal System Reusable confirmation, alert and prompt modals driven by typed signals and shared parameters.
- Localization System Runtime language switching, separate game and voice language tracks, and localized menus and modals out of the box.
- UI Themes ScriptableObject-based UI themes that share visuals and sound feedback across menus, modals and screens.
- View Navigation and History A provider-agnostic navigation stack that pushes views, tracks history and brings back-button support to any Unity UI without coupling to a specific menu or router.
- HUD System A HUD is a set of anchored elements bound to real game data through authored chains — built visually, validated automatically, and zero-migration as it evolves.
Media & Cinematics
- Audio Player Centralized clip playback with definition assets, emitters and typed signals for UI and gameplay sounds.
- Music Player Background music driven by track definitions, configurable transitions and typed signals you can hook into game state.
- Sound Mixer Per-category volume settings that drive your Unity Audio Mixer and persist through Game Settings.
- Sequence Player One generic async engine for every ordered multi-step flow — tutorial prompts, boss intros, phase changes — played by the same service, declarative instead of nested coroutines.
- Cutscene Player An ordered, timed cutscene player that plays fades, Unity Timelines and waits safely during boot, with a wizard and a live Timeline preview for authoring.
Gameplay
- Game Mode System Typed game state transitions with signals, pause strategies and a readiness gate that other systems can subscribe to.
- Checkpoint System A slot-based checkpoint service that separates the business rule of when to save from the storage detail of how and where.
- Game Session Management A centralized session service that owns the lifecycle of every run — status, elapsed time and identity — so no subsystem has to duplicate it.
- Multi-Metric Scoring System A dynamic scoring model that tracks any number of named metrics through a single service, returning immutable snapshots the game rules never have to own.
- On-Rails Movement System A passive, snapshot-based rail service that tracks normalized 0–1 progress along named node paths, keeping movement, AI and camera systems fully decoupled.
- Object Spawner and Pooling An entity spawning service that abstracts object pooling behind opaque handles so game logic never touches engine instantiation directly.
- Game Camera System One service that knows every camera in the scene, switches the active one without breaking your rigs, and lays out split-screen automatically.
- Leaderboard System A complete leaderboard stack — deterministic ranking, pluggable storage and a themeable UI — configurable end to end without writing a line of code.
- Game Saves & Progress Save slots with extensible sections for per-playthrough state, and a separate global progress aggregate for what should survive a deleted save.
- Wave System A wave spawner that scripts who spawns, where and when, chains waves into auto-advancing sets, and spawns them at named points on the stage that hosts them.
- Character System A character archetype system that validates every grunt, heavy and boss as data, tracks each live instance through its full lifecycle, and pairs with a pure weapon state machine for combat.
Game Feel & Feedback
- Gamepad Rumble and Controller Lighting A single feedback service that drives dual-motor rumble, LED lightbar color and Switch Pro HD vibration across PS5, PS4, Nintendo Switch Pro and generic gamepads.
- DualSense Adaptive Triggers Author DualSense adaptive trigger effects as ScriptableObject data and play them through a single service call — no HID code, no per-pad wiring.
- Screen Shake, Hit Stop and Screen Flash Screen shake, camera shake, UI shake, hit stop and full-screen flash — all authored in one FeedbackDefinition and triggered by a single service call.
- Procedural Animator Engine-agnostic procedural motion that composites additive PoseDelta contributions from weighted layers, lifecycle-driven actions and one-shot activation sequences — across five declared channels — onto any rig, prop or UI element.
Workflow & Tooling
Create your game.
Not the same systems, again.
Asset-driven Configuration
Define behavior through assets, not code.
Faster to iterate, safer to ship, and accessible to non-developers.
Ready-made Services
The systems you always end up building, already done.
Plug them in, adapt them, and focus on your game.
Independent, replaceable modules
Use the systems you need, swap the ones you don't, keep the rest untouched.
Adopt Serenity incrementally without rewriting your existing project.
Designed for real-world game development
No matter your role, Serenity has something for you.
Developers
- Plug systems in and start building
- Keep your code clean without extra effort
- Testable logic outside of MonoBehaviours
Designers
- Configure systems without code
- Make changes and see results
- Visual feedback and intuitive editors
Teams
- Work on a shared, consistent foundation
- Faster onboarding for new members
- Consistent project structure across the studio
Create systems that scale with your project
A solid foundation to stay organized, move faster, and reuse systems across projects.
Reuse everywhere
Create systems once and reuse them across projects instead of rebuilding from scratch.
Architecture that scales
Keeps your code organized and maintainable as your project grows.
Independence from Unity
Core systems independent from Unity; easier to test, reuse, and evolve.
One Hub for every tool you'll ever need
The Serenity Hub is the package's start-here front door — a searchable workspace that puts every tool, wizard and validator one click away.
89 tools, one searchable catalog
Every Tools ▸ Serenity entry lives in a single catalog, guarded by a staleness validator so the Hub can never silently drift out of date.
Wizards a non-programmer can walk
Every creation wizard runs on one shared step machine with a freely navigable breadcrumb, and rolls everything back atomically if it fails.
Validation only runs when you ask
The Validate view shows every validator as a card with its cached result and timestamp — opening the Hub never triggers a project scan.
Favorites & recents on Home
Pin the tools you use most; per-user, with no project assets touched.
Everything is one click — or one keystroke — away.
Everything working together; from editor to runtime
Configure in the editor. See it work instantly in-game.
Unity Inspector
Set up systems in the editor without code.
Runtime Systems
Systems working together in real time.
Architecture Diagrams
Understand how everything fits together.
No mockups. Real systems running in Unity.
Real-World Example
Tangible results, not just theories.
Reusable Wave System
- ScriptableObject-driven wave configuration
- Define spawn entries, enemy archetypes, and timing
- Reuse across multiple game modes without changing core logic
Used in: Survival • Tower Defense • RTS
Define waves via ScriptableObjects Configure → Reuse
Set the spawn points on the scene Production-ready systems included
Modular systems you can reuse across projects without rewriting core logic.
Core
Foundational systems that drive your game architecture
Event Dispatcher
Event Dispatcher
A high-performance, type-safe event bus enabling loose coupling between systems. Supports event prioritization, filtering, and automatic listener cleanup. Ideal for observer or message-driven architectures across independent modules.
Initialization Pipeline
Initialization Pipeline
A modular initialization framework that defines startup sequences, resolves dependencies, and manages service lifecycles. Supports asynchronous setup, dependency injection, and robust error recovery for predictable boot flow.
Logging
Logging
Production-ready logging system with verbosity profiles and console, file, and custom output sinks. Filter noise per system while debugging and keep a persistent trail for issues that only happen on players' machines.
Timer
Timer
Named timers, scaled or unscaled, managed by one central service and ticked in one place. Query, pause, and reset them from any system, and get display-ready formatted text for your HUD without writing formatting code.
Player Input
Player Input
Abstracts Unity’s Input System to provide unified keyboard, mouse, gamepad, and touch input. Includes dynamic device detection, rebinding, and multiplayer input mapping. Expose configurations via ScriptableObjects for designers.
Configuration
Data-driven systems to control behavior without code
Game Settings
Game Settings
Define, serialize, and validate game parameters through strongly-typed ScriptableObjects.
System Configuration
System Configuration
Environment-aware configuration system managing platform overrides, environment variables, and feature toggles. Supports runtime detection and layered profiles (development, staging, production).
Asset Prefetcher
Asset Prefetcher
Intelligent preloading system built around Addressables. Defines preload groups, tracks progress, and optimizes memory usage. Ensures assets are ready when needed for seamless scene transitions.
Game Graphics
Game Graphics
Runtime graphics configuration layer supporting resolution scaling, quality presets, and render pipeline detection (URP/HDRP/Built-in). Enables automatic hardware adaptation and persistent player preferences.
Data Persistence
Data Persistence
Platform-independent persistence built on store contracts with atomic writes, pluggable serialization, and optional encryption and compression. The same save code works across desktop and beyond.
User Interface
Reusable UI patterns and systems
Menu System
Menu System
Build complete menu flows (pause, settings, navigation) using data-driven definitions. Supports nested hierarchies, transitions, dynamic content, and consistent theming without manual UI scripting.
Modal System
Modal System
Generate confirmation dialogs, alerts, and complex modals programmatically or from data. Supports modal stacking, backdrop control, input blocking, and async/await workflows for clean UX flow.
View Browser
View Browser
Handles view transitions, history tracking, and state restoration. Includes forward/back navigation, deep linking, and persistence across reloads. Ideal for layered or tabbed UI systems.
Themeable Components
Themeable Components
Modular UI component set with theme switching, defined via ScriptableObjects and applied globally or per view. The Theme Builder wizard generates a complete, ready-to-run theme — 20 prefabs plus animations — from three colors, no cloning required.
Localization
Localization
Wraps Unity Localization behind game and voice language settings that plug straight into your menus. Players switch language from an options menu you didn't have to code, and validators catch missing keys before your players do.
HUD
HUD
Anchored HUD elements bound to real game data through configured binding chains, with seven representations from ammo counters to gauges. Built visually in the HUD Builder, edited by direct manipulation in the HUD Preview, and validated in CI so a renamed member can't silently blank an element.
Media
Audio and cinematic orchestration tools
Audio Player
Audio Player
Event-driven audio service supporting 2D/3D playback, crossfades, ducking, and priority-based management. Integrates with the Sound Mixer for dynamic mixing and efficient emitter pooling.
Music Player
Music Player
Plays and queries registered music tracks with seamless transitions, crossfades, loop regions, and start-point control. Bind tracks to game modes so the right music follows the player from menu to gameplay automatically.
Sound Mixer
Sound Mixer
Complete audio routing and mixing system with master, music, SFX, and voice buses. Supports volume persistence, effects chains, and runtime snapshots. Integrates with Unity’s AudioMixer or custom backend.
Cutscene Player
Cutscene Player
Plays ordered, timed stages — fades, waits, Unity Timeline — authored as simple assets, one-shot or looping. Comes with a step-by-step wizard, no-code triggers, and a live in-editor preview so you never enter Play mode just to check a cutscene.
Sequence Player
Sequence Player
The game-logic sibling of the Cutscene Player: run ordered sequences of timed steps for intros, phase changes, or scripted moments, keeping the flow declarative instead of buried in nested coroutines.
Gameplay
Higher-level systems built on top of the foundation; ready to use, extend, or replace.
Game Session
Game Session
Define how your game behaves across menus, gameplay, and pause without scattering logic across scenes. Keeps state transitions predictable and decoupled from Unity-specific code.
Game Mode
Game Mode
A typed state machine for your whole app: transitions are signals other systems subscribe to, pause behavior is a swappable strategy, and input maps, music, and scene loading stay coordinated without a hand-rolled GameStateManager.
Game Camera
Game Camera
One service that knows every camera in the scene (even inactive ones), switches the active camera without breaking Cinemachine rigs, and lays out local-multiplayer split-screen automatically as players join and leave.
Checkpoint
Checkpoint
Handle checkpoints as part of your game flow instead of wiring persistence manually. Supports multiple save points, scene transitions, and consistent state recovery out of the box.
Game Saves & Progress
Game Saves & Progress
GameSave keeps per-playthrough state in extensible, typed save slots; GameProgress keeps global unlocks and completion counts that survive slot deletion. Checkpoint quicksaves travel inside the active slot, and the same pluggable backends make cloud saves a configuration change.
Score
Score
Track and update score without spreading logic across systems. Supports multiple score sources and keeps scoring rules centralized and easy to modify.
Leaderboard
Leaderboard
A complete leaderboard stack: deterministic ranking with SQL RANK() tie semantics, pluggable storage from local files to SQLite, HTTP, or a real database, and a themeable view any menu can open with zero code. The five-step wizard configures it end to end.
Combo
Combo
A runtime consecutive-action counter that applies score multipliers. Feed it combo hits and breaks from your gameplay and let it handle the streak logic, so 'x4!' moments don't require their own subsystem.
Character
Character
Author character archetypes (grunt, heavy, boss) as validated config assets and let the runtime track every live instance's state. Balancing becomes editing an asset, not hunting through prefabs.
Wave
Wave
Define scripted spawn bursts — who, where, when, how many — as ordered wave sets that a stage advances through automatically. Designers tune encounters in the Inspector, with validation that flags empty spawn entries before they ship.
Stage
Stage
A stage is a prefab with a root and named spawn points that hosts your waves. Swap stages, reuse spawn layouts, and keep level structure consistent across the whole game.
Spawn
Spawn
Manage when, where, and how entities appear without hardcoding spawn behavior. Keeps spawning rules configurable and reusable across different game scenarios.
Rail
Rail
Move entities along rails without custom movement scripts. Ideal for guided gameplay, cameras, or on-rails mechanics while keeping logic decoupled and reusable.
Weapon
Weapon
Magazine, fire modes, trigger and reload handled as a runtime state machine you register and drive from code. Add weapons by configuring them, and keep firing logic out of your MonoBehaviours.
Feedback
Feedback
Bundle gamepad vibration, LED color, adaptive triggers, screen flash, hit-stop, screen shake, and audio into a single feedback definition, fired by id or by signal with zero code. DualSense, DualShock 4, and Switch Pro supported across platforms.
Procedural Animator
Procedural Animator
Rule-driven procedural motion — breathing, recoil, look-ats, flinches, one-shot activation sequences — blended additively over Unity's animation, with every layer declaring which of five channels it drives. Non-rig animators run the same pipeline on props and HUD elements. Bring characters and UI to life with configuration instead of extra animation clips.
Editor Tooling
Wizards, dashboards, and validators that hold your hand from first import to shipped game
Serenity Hub
Serenity Hub
One searchable workspace for all 89 Serenity tools — six views, Ctrl+K global search, favorites and recents — with your project's health at a glance and cached validation that only scans when you ask. Every issue deep-links to the tool that fixes it.
Setup Assistant
Setup Assistant
Scaffolds a working boot → main menu → gameplay → pause loop from an empty project, with live validation and a dry-run preview before anything is written. Your first hour with Serenity ends with a running game.
Theme Builder
Theme Builder
A step-by-step wizard that generates your theme asset, 20 ready-made prefabs, and show/hide and selection animations — registered into Addressables and ready to activate. No sample themes to clone, no manual wiring.
Validate Everything
Validate Everything
Aggregates health checks, missing references, localization gaps, Addressables labels, and audio registration into a single report. Fixable findings get Fix buttons that tell you exactly what will change before touching anything.
Safe Asset Delete
Safe Asset Delete
Deleting an asset that others still reference opens a review window listing every affected asset. Delete & Clean removes the asset and nulls out stale references automatically, logging everything it touched.
Signal Flow Browser
Signal Flow Browser
See cause → signal → effect as a node diagram with filters for unused signals, dispatchers, modals, and code reactions. Click any node to jump to the asset or script behind it.
Cutscene Live Preview
Cutscene Live Preview
The Cutscene Outline renders your cutscene — fades, waits, Timeline stages — through the rig's own camera inside the editor window. Iterate on timing without touching your open scene.
Animation Hub
Animation Hub
Model clips, standalone clips, animator controllers and procedural animation inventoried in one browse window — create and edit in place, preview clips live on the actual model, and simulate procedural profiles without touching your scene or assets.
Service Extension Creator
Service Extension Creator
Generates fully wired extension code for services, stores, repositories, gateways, factories, installers and even your own classes — no hand-written boilerplate to layer your logic on top of the framework.
AI Prompt Builder
AI Prompt Builder
A stepped wizard that interviews you about what you want to build, scans the project so the prompt extends your real assets instead of creating from scratch, and delivers the result to the clipboard, a file or an installed slash command — with a personal library of reusable instructions.
AI-Ready Recipes
AI-Ready Recipes
Menus, modals, audio, cutscenes, and settings described as recipe files that import idempotently into real assets — with validation, dry runs, and machine-readable reports, so designers and AI agents can build content safely.
Learn by seeing it working
Serenity is designed to be understood in context; not through isolated code snippets, but as a complete system working together.
This video series walks you through a fully configured project where all core systems are already in place. You won’t start from scratch; you’ll explore, understand, and then build on top of something real.
Each video focuses on a specific concept, showing how everything connects without unnecessary complexity or boilerplate.
Start from the first video or explore freely.
What you'll learn
This series is structured to help you progressively understand how Serenity works; from the big picture down to practical usage.
Explore real workflows
- How features are built using preconfigured systems
- How to extend behavior without breaking structure
Think in systems, not scripts
- How to approach development using decoupled architecture
- How to avoid tight coupling and repetitive code
By the end of this series, you won’t just know how to use Serenity; you’ll understand how to think with it.
Take your time exploring the videos; everything is already set up for you to follow along.
Skip the boilerplate. Start with First Steps.
Install the package, run the installer, and the nine core systems are already wired up. The documentation walks you through the rest.