Building Unity projects often leads to tight coupling, scattered logic, and systems that become harder to maintain over time.
VETORYX is an integration-ready, modular, event-driven architecture toolkit for Unity.
It provides lifecycle-driven module orchestration, decoupled communication through EventBus, and a clean separation between core logic and Unity-specific implementation — helping projects remain scalable and maintainable whether they are started from scratch or VETORYX is integrated gradually into an existing codebase.
Import the package into your Unity project and wait for compilation to complete.
VETORYX/Demo/Scenes/VETORYX_Demo_Builtin.unity
VETORYX/Demo/Scenes/VETORYX_Demo_Secondary.unity
For the complete setup process, including demo scene configuration and input settings, see the Quick Start guide.
- Add both demo scenes to Build Settings.
- Set Active Input Handling to Both.
Edit → Project Settings → Player
Space→ Increase scoreS→ SaveL→ Load
Demonstrates event-driven score updates and the included demo save/load flow.
Space→ Toggle between Menu and Gameplay states
Demonstrates structured state transitions through GameStateModule.
If both scenes run without runtime errors, VETORYX has been imported and initialized correctly.
VETORYX is built around a modular lifecycle system.
Core components include:
IModuleinterfaceModuleRegistry- Lifecycle phases:
Register → Initialize → Start → Shutdown - Central
EventBusfor decoupled communication - Clear separation between domain logic and Unity integration
Systems communicate through structured events rather than direct references.
VETORYX is designed to be integrated into existing Unity projects without forcing a full rewrite of current systems.
You do not need to replace your gameplay logic, scene setup, input handling, save logic, UI controllers, scene flow, or existing MonoBehaviour components all at once.
Instead, VETORYX can be introduced gradually, one system or feature at a time.
A typical integration flow looks like this:
- Import VETORYX into your Unity project.
- Open the first scene that runs when your game starts.
- Create an empty GameObject in that scene.
- Add the
VETORYXApplicationBootstrappercomponent to that GameObject. - Press Play to let the bootstrapper initialize the core VETORYX runtime.
- Connect existing systems through events, adapters, or small bridge components.
- Move logic into VETORYX modules only when it makes sense.
This allows your current project structure to remain intact while VETORYX provides a cleaner orchestration layer around it.
For example, an existing score system, save system, UI controller, or scene loader can keep its current implementation.
VETORYX can publish and listen to events around those systems, making communication cleaner without breaking the original behaviour.
The goal is not to replace your project architecture overnight.
The goal is to give your project a stable modular layer that can grow with it.
See the Integration guide for the complete integration workflow.
VETORYX includes core systems and modules implemented within the same modular architecture exposed to the user.
Core systems and modules include:
EventBusfor decoupled communicationModuleRegistryfor module lifecycle managementGameStateModulefor game state flowInputModulefor input abstractionDemoSaveModulefor the included demo save/load flowDiagnosticsModulefor diagnostics and runtime feedbackSceneManagementModulefor scene management flow
Each module:
- Registers through the
ModuleRegistry - Participates in the lifecycle pipeline
- Communicates through
EventBuswhere appropriate - Avoids direct system coupling
- Can be extended or replaced depending on project needs
VETORYX/
├── Core/
├── Modules/
├── Runtime/
├── Demo/
├── Docs/
- Implement
IModule. - Register the module through
ModuleRegistry.AddModule(...). - Use
EventBusfor communication where appropriate. - Avoid direct references between modules.
- Unity 2022.3 LTS — recommended and tested
- Unity 6 / 6000.x — tested
- No required third-party dependencies
VETORYX is not a template.
It is a structural foundation for Unity projects that need to scale cleanly.










