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
Twelve reusable Unity systems documented one by one: what they solve, how they fit together and when to use them.
- Unity Menu System Declarative menus, shared UI themes and predictable navigation, configured as assets instead of hand-wired GameObjects.
- Unity Modal System Reusable confirmation, alert and prompt modals driven by typed signals and shared parameters.
- Unity Localization System Runtime language switching, separate game and voice language tracks, and localized menus and modals out of the box.
- Unity Audio Player Centralized clip playback with definition assets, emitters and typed signals for UI and gameplay sounds.
- Unity Music Player Background music driven by track definitions, configurable transitions and typed signals you can hook into game state.
- Unity Sound Mixer Per-category volume settings that drive your Unity Audio Mixer and persist through Game Settings.
- Unity Game Settings Typed get and set use cases for bool, int, float and string settings, with persistence and update signals built in.
- Unity Game Mode System Typed game state transitions with signals, pause strategies and a readiness gate that other systems can subscribe to.
- Unity Event Dispatcher Typed signals dispatched through a service, with auto-registration support and no static singletons.
- Unity Input System Integration A player input gateway that routes Unity Input System actions to menus, gameplay and UI navigation through clean services.
- Unity UI Themes ScriptableObject-based UI themes that share visuals and sound feedback across menus, modals and screens.
- Unity Addressables Workflow Service-based asset prefetcher with contexts, labels, cache policies and prewarm tasks for Unity Addressables.
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.
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 supporting console, file, and custom output sinks.
Timer
Timer
Service that allows you to manage timers to be used in different systems. Allows you to get the representative text of the timer
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 service.
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. Themes are defined via ScriptableObjects and applied globally or per view. All components follow Clean Architecture and decouple visuals from logic.
Media
Audio and cutscene 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
Handles seamless track transitions, crossfades, and adaptive layers.
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
Manages cutscenes built in Unity Timeline or custom sequences. Supports skipping, pausing, subtitles, and automatic state restoration. Integrates with gameplay systems for smooth narrative transitions.
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.
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.
Score
Score
Track and update score without spreading logic across systems. Supports multiple score sources and keeps scoring rules centralized and easy to modify.
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.
Spawn
Spawn
Manage when, where, and how entities appear without hardcoding spawn behavior. Keeps spawning rules configurable and reusable across different game scenarios.
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.