EasyCS
EasyCS is an easy-to-use and flexible framework for Unity, adopting a Data-Driven Entity & Actor-Component approach. It bridges Unity's classic OOP with powerful data-oriented patterns, without forcing a complete ECS paradigm shift or a mindset change. Build smarter, not harder. 🎮🧩
Install / Use
/learn @Watcher3056/EasyCSREADME
🧩 EasyCS: Data-Driven Entity & Actor-Component Framework for Unity
EasyCS is an easy-to-use and flexible framework for Unity designed to empower developers with a flexible and performant approach to structuring game logic. It bridges the gap between traditional Object-Orientated Programming (OOP) in Unity and the benefits of data-oriented design, without forcing a complete paradigm shift or complex migrations.
At its core, EasyCS allows you to:
- Decouple data from logic: Define your game data (e.g., character stats, inventory items) as plain C# objects (Entities) independent of Unity's MonoBehaviour lifecycle.
- Organize logic cleanly: Implement game behaviors (Systems) that operate on this decoupled data, promoting modularity and testability. Crucially, Systems are an optional feature in EasyCS; you decide if and when to use them.
- Integrate seamlessly with Unity: Connect your data-driven logic back to your GameObjects and MonoBehaviours, providing granular control without sacrificing Unity's intuitive editor workflow.
- Maximize ScriptableObject utility: EasyCS provides robust tools to work with ScriptableObjects, significantly reducing boilerplate and enhancing their utility for data management.
Unlike traditional ECS solutions, EasyCS offers a gradual adoption path. You can leverage its powerful features where they make sense for your project, without the high entry barrier or full migration costs often associated with other frameworks. This makes EasyCS an ideal choice for both new projects and for integrating into existing Unity codebases, even mid-development.
📚 Table of Contents
- 🧩 EasyCS – Data-Driven Entity & Actor-Component Framework for Unity
- 🚀 Why EasyCS?
- 🌟 Features at a Glance
- 🔍 Comparison Table
- 📦 Dependencies
- ❔ FAQ
- Is EasyCS just another ECS framework?
- Is EasyCS as complex and slow to develop with as other ECS frameworks?
- EasyCS vs. other ECS (like Unity DOTS)?
- I'm using DI (Zenject, VContainer) do I need EasyCS?
- Is EasyCS suitable for Junior, Mid, or Senior developers?
- What kind of games can be made with EasyCS?
- What kind of games are not ideal for EasyCS?
- Do I need to update all MonoBehaviours to EasyCS?
- Can Entity & Data exist without GameObjects?
- How to migrate my MonoBehaviours to EasyCS?
- ⚙️ Setup
- 📚 Examples
- 💬 Join the Community
- 📂 Getting Started
- 🐣 Basics
- 🧭 Advanced
- 🤝 Contributing
- 💖 Support the Developer
- 📝 License
🚀 Why EasyCS? Solving Common Unity Development Challenges
Many Unity developers, especially those working on simple to mid-core projects, face similar hurdles when building games or considering alternative architectures. EasyCS was created to address these common challenges directly and offer a more accessible pathway to improved architecture:
- Painless Integration & Gradual Adoption: Integrating a full ECS framework mid-project can be a daunting, risky, and sometimes impractical task, especially for teams unfamiliar with ECS. EasyCS is built for simple integration into any project, at any stage. You don't need to refactor everything; apply its principles incrementally where they can provide the most benefit. This flexibility makes it ideal for fast-paced prototyping and for teams looking to improve their codebase without a massive overhaul.
- Lower Entry Barrier & Familiar Workflow: Traditional ECS often presents a steep learning curve and demands a significant shift in thinking. EasyCS lets you continue working with MonoBehaviours as you're used to, while providing tools to introduce data-oriented principles when beneficial. It's designed as a framework for beginners to ECS, offering a gentler introduction without overwhelming complexity.
- Automated Data Management with ScriptableObjects: Unity's ScriptableObjects are powerful for data, but often require manual setup and boilerplate. EasyCS provides fully automated creation and management for data configurations using ScriptableObjects, drastically reducing routine work and improving your workflow for game data.
- Clear Execution Flow: Unlike Unity's default MonoBehaviour execution order, which can sometimes be unpredictable across multiple scripts, EasyCS provides a clear, defined order for initialization and updates (e.g., OnAwake, OnUpdate). This predictability makes debugging and understanding complex systems much easier.
- Better Unity Experience: Unity's default approach can get messy as projects grows. EasyCS aims to improve how you work in the Unity editor by giving you a more organized way to manage game data and logic. It brings architectural benefits without making you abandon familiar Unity tools.
- Practicality First: Most game projects don't fully switch to ECS, despite its architectural strengths. EasyCS offers a balanced, practical solution. It's not meant to replace powerful, production-level ECS frameworks, but to provide a clear, understandable option for common development tasks where ECS principles help, but a full migration isn't needed or wanted.
EasyCS is an evolving framework designed to be intuitive and easy to integrate. It helps developers solve real problems like separating data and logic, or using ScriptableObjects efficiently, all without the high barrier to entry or big refactoring demands of other solutions. It's about empowering Unity developers to build stronger, more maintainable games, step by step.
🌟 Features at a Glance
- 🔀 Split Behavior and Data layers – Provides a clean separation between logic (behaviors) and state (data), making systems more modular, testable, and reusable.
- 🏗️ Entity and Unity Layers – Organize your logic and data either on the Unity side or within Entity, depending on your needs.
- ✅ Familiar Workflow – Work with Unity GameObjects, Prefabs and ScriptableObjects even better than before!
- 🧠 Prefab-based Entity Construction – Design Entity as prefabs and serialize in ScriptableObjects
- 📦 ScriptableObjects Data – All data can be automatically packed in ScriptableObjects when you need it. Forget about writing ScriptableObjects like in old days!
- 💡 Zero-Delay ECS – No deferred execution; all changes apply instantly
- 🔧 Editor-first – Designed with custom inspector tooling and editor extensions
- 🧙 Odin-Compatibility - Compatible with OdinInspector & Odin-Validator
- 🔗 Supports Cross-scene & Cross-session References – Maintain links between entities and GameObjects across the scenes!
- 🧱 Framework-Agnostic – Drop-in ready with Zenject or VContainer support (Optional)
🔍 Framework Comparison Table
| Feature / Capability | Classic Unity | Zenject / VContainer DI | Classical ECS | 🧩 EasyCS | |--------------------------------------------|---------------------------|---------------------------------------------|-----------------------------|--------------------------------------| | ✅ ScriptableObject Integration | ❌ Manual, boilerplate | 🟡 Manual or per-pattern | ❌ Not used | ✅ Native + Automated | | 🧱 Component Modularity | 🟡 MonoBehavior composition | 🟡 Service-level modularity only | ✅ System-defined archetypes | ✅ Behavior + Data Layers | | 🔄 Instantiate / Destroy Entities | 🟡 GameObject.Destroy | 🟡 Unity-style destruction | ✅ Built-in, loop-friendly | ✅ Entity-aware creation/destruction| | 💾 Save System Compatibility | ❌ Requires boilerplate | 🟡 DI-friendly but needs logic | ✅ Loopable + serializable data | ✅ Loopable + serializable data | | 🧩 Entity Construction | ❌ Manual Mono setup | 🟡 Scene installers + custom prefabs | ✅ Data-defined archetypes | ✅ Prefab
