Pulse – GC-Free Event System with Live Debugger

Stop guessing where your events come from.

Pulse is a GC-free event system for Unity with a built-in live debugger that shows exactly who sent a signal, who received it, and how it propagated through your game.

No more digging through logs. No more guessing which system fired an event.

Key Features

• GC-free event dispatch

• Built-in live event debugger (PulseScope)

• Timeline visualization of signal flow

• Breakpoints for event dispatch

• Multiple event buses

• Simple and clean API

• Designed for high-frequency gameplay events

In larger Unity projects, events quickly become difficult to track.

Execution order becomes unclear.

Call chains are hidden.

Debugging often turns into guesswork.

When something breaks, you’re left searching through logs and code trying to figure out who fired an event and why.

Pulse solves this problem.

Pulse combines a fast, allocation-free signal system with PulseScope, a powerful built-in debugger that lets you inspect your events in real time.

You can see exactly what happens when signals are dispatched and how they propagate through your game.

PulseScope – Built-in Event Debugger

PulseScope gives you complete visibility into your event system.

See exactly:

• Who raised a signal (script + line number)

• Which object sent it

• Who received it

• Execution order of listeners

• What payload was sent

• When it happened

• Signal flow visualized in a timeline

• Breakpoints to pause on dispatch

Track signal chains instantly and understand complex interactions without relying on logs.

Simple API

Emit a signal:

Pulse.Emit(new OnPlayerHit(data));

Subscribe to a signal:

Pulse.Subscribe<OnPlayerHit>(OnPlayerHit);

Use multiple event buses if needed:

Pulse.Bus("Combat").Emit(new OnPlayerHit(data));

Built for Performance

Pulse is designed for high-performance gameplay systems.

Zero garbage collection is achieved when monitoring in PulseScope is disabled.

Monitoring is automatically disabled in builds, ensuring optimal runtime performance while still providing powerful debugging tools during development.