A production-ready, modular Unity project template that provides a solid foundation for game development. Inspired by Unreal Engine architecture patterns, this template integrates proven gameplay systems, high-performance infrastructure, and modern development workflows.

English | 简体中文

1. Overview
2. Key Features
3. Architecture
4. Module Catalog
5. Getting Started
6. Technology Stack
7. Related Projects

This template is designed for developers who want to start with a professional, battle-tested foundation rather than building everything from scratch. It provides:

• Modular Architecture: All systems are decoupled Unity Packages with independent Assembly Definitions
• Unreal Engine Patterns: Proven architecture concepts (Gameplay Framework, GAS, Gameplay Tags)
• Performance-First: Zero/low-GC systems for critical paths
• Production-Ready: Tested in commercial projects, CI/CD ready, cross-platform optimized
• Developer-Friendly: Comprehensive documentation, clear examples, flexible DI/IoC support

• ✅ Complete gameplay framework (Actor/Pawn/Controller/GameMode pattern)
• ✅ Data-driven ability system (GAS-inspired)
• ✅ High-performance infrastructure (logging, pooling, audio)
• ✅ Hot update solution (code + assets)
• ✅ Code obfuscation integration (Obfuz) for code protection
• ✅ Build pipeline with CI/CD integration
• ✅ Modern input system with context stacks
• ✅ UI framework with hierarchical management and MVP architecture support

📖 Documentation: Each module has comprehensive documentation. See the Module Catalog section for links to detailed guides.

Every system is a self-contained Unity Package. Import only what you need, remove what you don't. Each module has:

• Independent Assembly Definition (asmdef)
• Complete package.json configuration
• Comprehensive documentation
• Sample implementations

Implements proven patterns from Unreal Engine:

• Gameplay Framework: Actor/Pawn/Controller separation for scalable game architecture
• Gameplay Ability System: Data-driven abilities, attributes, and effects
• Gameplay Tags: Hierarchical tag system for decoupled game logic

Critical systems are optimized for GC:

• Logger: Zero-GC multi-threaded logging with file rotation
• Factory: High-performance object pooling with O(1) operations
• Audio: Low-GC audio management with Wwise-like API

Complete solution for updating games without app store resubmission:

• HybridCLR: C# code hot-updates via DLL compilation
• Asset Management: YooAsset or Addressables for asset hot-updates
• Code Protection: Integrated Obfuz obfuscation for hot update assemblies
• Unified Pipeline: Streamlined build workflow for rapid iteration

Pre-configured adapters for popular dependency injection frameworks:

All listed frameworks have been tested in production environments.

• VContainer (Recommended)
• StrangeIoC
• Extenject (Zenject) (No longer actively maintained)

Note: Switch between Git branches to see implementation examples for each DI framework. The GameplayFramework and Factory modules include DI samples.

Command-line build interface for automated pipelines:

• Automatic versioning from Git
• Multi-platform builds (Windows, Mac, Android, WebGL)
• Hot update build workflows with optional code obfuscation
• Integration with Jenkins, TeamCity, GitHub Actions

.
├── Docs/                          # Project documentation
├── Tools/                         # Utility scripts (renaming, cleanup, etc.)
└── UnityStarter/                  # Unity project root
    ├── Assets/
    │   ├── Build/                 # Build pipeline & hot update
    │   │   └── [See Build/README.md for details]
    │   └── ThirdParty/
    │       └── CycloneGames/      # Core framework modules
    │           └── [Each module has its own README]
    ├── Packages/                  # Package manifests
    └── ProjectSettings/           # Unity settings

All modules follow the same structure:

• Runtime/: Core functionality
• Editor/: Editor tools and utilities
• Samples/: Example implementations
• README.md / README.SCH.md: Comprehensive documentation

Modules are designed to be:

• Loosely Coupled: Minimal dependencies between modules
• Optional: Most modules can work independently
• Composable: Mix and match based on your needs

📚 Important: Each module has detailed documentation in its directory. Click the module name to view its README, or navigate to {ModulePath}/README.md for comprehensive guides.

• Unity 2022.3 LTS or later
• Git (for automatic versioning in Build module)
• Basic familiarity with Unity and C#

git clone https://github.com/MaiKuraki/UnityStarter.git

If using as a full project template:

1. Locate Tools/Executable/rename_project executable
2. Copy it to UnityStarter/ directory
3. Run from command line - it will guide you through:
   • Project folder renaming
   • Company name updates
   • Application name changes
   • Configuration file updates

1. Open Your Project from UnityHub

1. Start with Core Modules: Begin with GameplayFramework
2. Read Documentation: Each module has a README.md in its directory
3. Check Samples: Most modules include sample scenes and scripts
4. Configure Build: See Build Module Documentation for setup

If you only need specific modules:

Recommended Method (Package Manager):

1. Copy module folder outside your Assets directory
2. In Unity: Window > Package Manager
3. Click + > Add package from disk...
4. Select the module's package.json file

Simple Method (Direct Copy):

1. Copy module folder from UnityStarter/Assets/ThirdParty/CycloneGames/
2. Paste into your project's Assets folder

💡 Tip: Check each module's README for specific setup instructions and dependencies.

• Unity: 2022.3 LTS+
• UniTask: Async/await for Unity (GitHub)
• R3: Reactive programming (GitHub)
• LitMotion: Animation/tweening (GitHub)
• VYaml: YAML serialization (GitHub)
• VitalRouter: Message bus (GitHub)

• HybridCLR: C# hot-update (GitHub)
• Obfuz: Code obfuscation (GitHub)
• Obfuz4HybridCLR: Obfuz extension for HybridCLR (GitHub)
• YooAsset: Asset management (GitHub)
• Addressables: Unity's asset management (via Package Manager)
• Mirror: Networking (GitHub)
• Navigathena: Scene management (GitHub)
• MessagePack: Binary serialization (GitHub)

See UnityStarter/Packages/manifest.json for complete dependency list.

Projects built using this template:

• Rhythm Pulse - Collection of rhythm game mechanics and gameplay types
• Unity Gameplay Ability System Sample - Example project demonstrating GAS implementation

📚 Each module has comprehensive documentation in its directory.

1. Navigate to Module Directory: UnityStarter/Assets/ThirdParty/CycloneGames/CycloneGames.{ModuleName}/
2. Look for README Files:
   • README.md - English documentation
   • README.SCH.md - Simplified Chinese documentation
3. Check Samples Folder: Most modules include example implementations

• GameplayFramework - Complete guide to Actor/Pawn/Controller architecture
• GameplayAbilities - GAS system tutorial with step-by-step examples
• Build - Build pipeline setup and CI/CD integration
• InputSystem - Input system configuration and usage
• UIFramework - UI framework architecture and examples
• AssetManagement - Asset loading and version management

License: See LICENSE file for details.

Support: For questions and discussions, please open an issue on GitHub.