【RELEASED】 GameEventSystem(GES) - Professional Visual Event Architecture for Unity

[TinyGiants]

Hello Unity Community!

I’m excited to share GameEventSystem with you — a production-ready visual event architecture built to solve the problem that haunts every Unity project: invisible, unmaintainable event spaghetti.

Game Event System for Unity | Decoupled Architecture with ScriptableObjects

Status: Released on Asset Store (current version v1.3.0)

GES is part of the TinyGiants toolset — see the TinyGiants Hub thread for all products.

A Note from the Creator

As an indie developer, I learned the hard way that the Event System is the nervous system of any game — it touches everything. I spent more time debugging invisible event chains than building gameplay.

I tried existing solutions, but each had compromises: visual-only tools lacked coding flexibility, code-heavy frameworks were impossible to visualize, and performance was sacrificed for convenience.

So I built the tool I always wished existed — one that delivers visual management, code control, and zero overhead in a single package.

Happy coding,
[TinyGiants] from China

What is GameEventSystem?

GameEventSystem (GES) is a production-ready visual event architecture for Unity that transforms chaotic event management into maintainable, testable workflows.

The Problem

• Hidden Dependencies: Who’s listening? Where’s it triggered?
• Runtime Breakage: Rename a method, break 10 scene objects silently.
• Cross-Scene Hell: Events die when scenes unload.
• No Visibility: Complex event chains exist only in your head.

The Solution

Events as Assets — ScriptableObject-based, GUID-protected, survives refactoring
Visual Flow Graphs — See your event chains, triggers, and conditions in one window
Zero-Reflection Runtime — Expression Tree compilation, compiled-delegate performance
Designer-Friendly — Drag-and-drop binding, no coding required for simple workflows
Production-Grade Tools — Real-time monitoring, reference finding, code generation

Key Features

Core Architecture

Feature	Description
Asset-Based Events	ScriptableObject with GUID identity — references survive renames and moves
Comprehensive Generics	GameEvent, GameEvent<T>, and GameEvent<TSender, TArgs>
Multi-Database System	Modular organization for large teams with dynamic loading
Category System	Fuzzy-search filtering within large event libraries
Auto Static Reset	Automatic clearing of static caches to prevent data pollution

Advanced Logic & Flow

Feature	Description
Expression Trees	Zero-reflection condition evaluation compiled to delegates
Visual Logic Builder	Nested AND/OR logic without code
Hybrid Execution	Mix parallel Triggers and sequential Chains in one graph
Argument Transformers	Extract and pass properties between flow nodes
Granular Control	Per-node delays, async waits, loops, condition gates

Listening & Binding

Feature	Description
Visual Binding	Drag-and-drop UnityEvent wiring with type safety
Priority Listeners	Integer-based execution order control
Conditional Listeners	Predicate-based filtering
Persistent Listeners	Cross-scene listeners that survive transitions
Runtime API	Full programmatic listener management

Tooling & Debug

Feature	Description
Dashboard & Wizard	Batch operations and fuzzy-matching creation
Code Automation	Tri-Mode CodeGen (Basic/Custom/Sender)
Reference Finder	Scene-wide dependency scanner
Runtime Monitor	Real-time profiling (execution time, GC, listener counts)
Automation Tree	Live Trigger/Chain hierarchy visualizer

Performance

Scenario	Performance	Notes
Event Raise (0 listeners)	~0.001ms	Virtually free
Event Raise (10 listeners)	~0.02ms	No GC allocation
Condition Evaluation	~0.003ms	Expression Tree compilation
Flow Node Execution	~0.05ms	Includes coroutine overhead
Monitor Window (100 events)	~0.3ms	Editor-only, no runtime cost

Tested with 500+ events and 10,000+ listeners in production.

See It In Action

Flow Graph Editor — your event chains, finally visible

Design parallel Triggers and sequential Chains on one canvas, with typed ports, per-node delays, and live validation.

Game Event Editor — hundreds of events, under control

Browse, filter, and edit every event across databases and categories from a single window.

Behavior Window — designer-friendly responses

Wire conditions, UnityEvent actions, delays, and repeats onto any event — no code required.

Runtime Monitor — observability built in

Live dashboard with per-event execution timing, GC tracking, listener counts, and warnings while you play.

And more under the hood — System Dashboard, batch Event Creator, Tri-Mode Code Generator & Cleaner, scene-wide Reference Finder, and type-safe Inspector dropdowns. The full visual tour lives in the documentation.

Code That Stays Simple

Everything you see visually is also a first-class scripting API:

public class GameEventRaiser : MonoBehaviour
{
    [GameEventDropdown] public GameEvent voidEvent;
    [GameEventDropdown] public GameEvent<DamageInfo> customEvent;
    [GameEventDropdown] public GameEvent<GameObject, DamageInfo> senderEvent;

    private void Start()
    {
        var damageInfo = new DamageInfo(100, false, DamageType.Void, Vector3.one, "sender");

        voidEvent.Raise();
        customEvent.Raise(damageInfo);
        senderEvent.Raise(gameObject, damageInfo);
    }
}

Technical Blog Series

I’ve published a 16-part blog series covering every aspect of event-driven architecture in Unity. Each article starts with a real problem, then shows how GES solves it.

Available in English & 中文 on the website.

Foundation

#	Article	What You’ll Learn
1	Goodbye Invisible Spaghetti	Why traditional event systems create invisible dependencies
2	Unity’s Generic Serialization Wall	Type-safe events without boilerplate for every type
3	Zero Reflection, Zero GC	What “high performance” actually means — with benchmarks
4	200 Events and Counting	Why event organization breaks down at scale
5	5-Minute Quickstart	From install to working event system in 5 minutes

Visual Workflow

#	Article	What You’ll Learn
6	The Designer-Programmer Handoff	Non-coders configuring event responses
7	Escape if-else Hell	Visual conditional logic that scales
8	Invisible Event Chains	You can’t debug what you can’t see
9	Parallel vs Sequential	The two execution patterns every event system needs

Runtime & API

#	Article	What You’ll Learn
10	Time-Based Events	Why coroutines are wrong for delays and repeats
11	Execution Order Bugs	The hidden danger of “who responds first”
12	Runtime Event Flows	Building event flows at runtime

Production

#	Article	What You’ll Learn
13	Event System Pitfalls	Memory leaks, data pollution, recursive traps
14	Debugging the Invisible	Event systems need their own observability
15	Cross-Scene Persistence	The persistence problem nobody talks about
16	Layering Visual & API Events	When to use visual tools vs the scripting API

Each article is posted as a reply below for easy reading, or visit the full blog for the best experience with code highlighting and language switching.

15 Example Scenes

ID	Example	Key Learning
00	Quick Start	Minimal workflow: create, raise, bind
01	Void Event	Parameterless signals for global triggers
02	Basic Types	Passing int, float, string through events
03	Custom Type	CodeGen for custom data classes
04	Sender Event	Source-aware events identifying the raiser
05	Priority	Controlling execution order of listeners
06	Conditional	Predicates that gate callback execution
07	Delayed	Timed logic with Task Handle cancellation
08	Repeating	Recurring pulse signals and automated loops
09	Persistent	Events surviving scene transitions
10	Trigger	Parallel fan-out event flows
11	Chain	Sequential logic via Flow Graph
12	Multi Database	Modular event organization
13	Runtime API	Dynamic listener registration via C#
14	Runtime Monitor	Profiling execution timing and GC

Official Links

• TinyGiants Homepage
• Asset Store
• Documentation (English · 中文)
• Blog (English · 中文)
• YouTube Channel
• Discord Community
• Email Support

Community & Support

Discord (Recommended)

Real-time answers, roadmap updates, beta access, 24/7 global community.

Join Discord

Direct Support

support@tinygiants.tech — Response within 24-48 hours.

Lifetime License

Your purchase includes lifetime updates. No subscriptions.

Professional tools for professional developers.
[TinyGiants]