Actor Framework

A Unity Engine performance-oriented workflow inspired by Unreal's Actor model.

A Unity framework that rethinks the GameObject/Component workflow, adding ActorObjects, subsystems, and utilities for faster lookups, better organization, and a smoother development experience.

Overview

The Unity Actor Framework brings Unreal-style workflows into Unity. At its core, it replaces GameObjects with ActorObjects that support inheritance, multi-tagging, cached component tracking, and built-in damage handling. On top of that, it adds specialized Actor types (CharacterActor, PhysicalActor), powerful pre-built components (ProjectileMovement, RadialForce, Hitbox), and a full subsystem layer for managing game-wide logic (Pooling, Delays, CombatCoordinator, Lifecycle). Finally, a central GameSystem ties it all together with APIs like GetSubsystem<T>() and ApplyDamage(). The result is a cleaner, more scalable way to build games in Unity; faster to prototype, easier to extend, and better performing at runtime.

The Problem

Unity's component system is flexible but shows its limits in larger projects. Frequent GetComponent calls add up, tag-based searches are limited, and basic systems like pooling or subsystems have to be rebuilt from scratch. This leads to cluttered, repetitive code and runtime inefficiencies.

The Solution

The Actor Framework solves these issues by introducing Actors with lifecycle control, cached components, and multi-tagging. It ships with specialized Actor types, a growing library of pre-built components (like projectile movement and radial forces), and subsystems for pooling, combat coordination, and delays. Developers can rely on the central GameSystem for consistent access to subsystems and gameplay utilities, keeping codebases lean and maintainable.

Challenges & Learnings

The biggest challenge was keeping the framework lightweight and intuitive while still adding meaningful performance gains. Profiling Unity's internals was key to designing caching and lookup systems that reduced overhead without adding complexity. Balancing power with simplicity was the main design goal.

Visuals

Benchmarks show up to 5.7x faster component lookups and nearly 3x faster tag checks per 100 operations.

Technical Details

Actors

Actors are upgraded GameObjects with inheritance, lifecycle hooks, a dependency system, and multi-tagging. Specialized types like CharacterActor and PhysicalActor add built-in features such as health, armor, ragdolls, and impact-based damage.

Component System

Components inherit from ComponentBase, giving them access to owner Actors, initialization order, and component tags. Pre-built components include a feature-rich ProjectileMovementComponent, a RadialForceComponent for physics impulses, and bone-based Hitbox components with custom multipliers.

Subsystems

Subsystems provide structured entry points for global logic. SceneSubsystems run when levels start, while GameInstanceSubsystems persist across the entire game. Built-in subsystems include pooling, delay scheduling, combat coordination, and lifecycle management.

Utilities

A rich utility library ships with helpers and extensions for coroutines, NavMesh, UI, math, and world queries. The framework also includes a central GameSystem that manages initialization and provides global APIs such as GetSubsystem<T>(), ApplyDamage(), and ApplyRadialDamage().

Outcome & Impact

Benchmarks show up to 5.7x faster component lookups and nearly 3x faster tag checks compared to Unity defaults. In combat tests with dozens of enemies, the framework eliminated GC allocations and kept framerate stable, proving that it is both cleaner and more performant.

My Role

Designed, developed, profiled, and documented the entire framework.

Want to try the Actor Framework?

I'm considering making it open source for everyone to try and contribute. Reach out if you'd like to test it or give feedback.