Flow Playback
Flow playback shows you items moving through your design. The simulator only ticks when something actually happens (a block finishing an item, a retry firing, a circuit breaker reopening, an item arriving on a slow line) instead of running on a fixed clock. Each frame is a cluster of events at the same simulated time.
Timeline bar
Section titled “Timeline bar”The timeline bar floats at the bottom of the canvas. Drag it by the grip to move it. Click the pin to put it back. It has playback controls, a scrub bar, and time / frame readouts.
Controls
Section titled “Controls”| Control | What it does |
|---|---|
| Play / Pause | Start or pause playback (Ctrl+Space). |
| Step Forward (>) | Advance one frame (Right Arrow). |
| Step Back (<) | Go back one frame (Left Arrow). |
| Reset | Jump back to the start and clear highlights. |
| Seed Items | Set how many items to drop at entry blocks (1-1000). Type a number or use the arrows. |
Live counters
Section titled “Live counters”Five compact counters live next to the play controls:
| Icon | Counter | What it means |
|---|---|---|
| ↓ | Entered | Total items that came into the system. |
| ↑ | Delivered | Items that reached an exit block. |
| Filter | Filtered | Items intentionally dropped by filter-mode blocks (only shows when more than 0; purple). |
| Skull | Lost | Items lost to failures (queue overflow, circuit breaker, throttle, retries used up). Only shows when more than 0. |
| Queue | Queued | Items currently waiting in block queues. |
Scrub bar
Section titled “Scrub bar”The colored bar is the full timeline. Each segment is sized by how much time passes between frames (not evenly), so a 200ms step takes more space than a 5ms one.
Segments use six colors based on what happened that frame:
- Slate: nothing happened (no items in or out).
- Green: healthy, no drops, queue 2 or fewer.
- Purple: a filter-mode block dropped some items on purpose.
- Amber: queue is over 2 (pressure building).
- Orange: queue over 50 (bad backup, no drops yet).
- Red: items were lost to a failure this frame.
Past frames are full color. Future frames are dimmed to 30% as a preview. Click or drag anywhere on the bar to jump to that frame. Hover for a tooltip with the per-block detail at that moment.
Below the bar, a counter shows the current time (clock icon) and frame (film icon), with 0 on the left and the total run time on the right.
Detail panel
Section titled “Detail panel”Click the chevron at the right of the timeline to open the detail panel. It shows:
- Time at this frame, the longest path duration, and the run window.
- Per-block activity: a plain-English line for every active block (e.g. “received 3 from Fetch, processed 2, dropped 1, 2 queued, sent to Parser”). The verbs match the block’s behavior — “released” for queues, “passed” for filters, “transformed” for transforms.
- Insight: a short note about the frame (“Backing up at Parser (3 waiting)” or “Fetch losing items”).
- Alert badges: critical (queue backed up), failure (items lost), or warning per block.
- Bottleneck callout: names the current bottleneck if there is one.
- Run summary: when the run ends and playback pauses, you get a recap of the whole thing.
Stats bar
Section titled “Stats bar”While a run plays, a small stats bar sits in the middle of the top bar — a heads-up display that doesn’t cover the canvas.
What it shows
Section titled “What it shows”| Element | What it means |
|---|---|
| Health % | Overall system health (0-100%) with color: green (≥ 80%), amber (≥ 50%), orange (≥ 25%), red (< 25%). Filter drops don’t hurt the score. |
| In / Out / Filtered / Lost / Queue | Same counters as the Overview panel. Filtered (purple) only shows up if a filter-mode block dropped something. Lost (red) only shows up if there were real failures. |
| Delivery bar | A bar showing the delivery rate: delivered ÷ (delivered + dropped). |
Behavior
Section titled “Behavior”- Shows up automatically when a run is playing.
- Hides when there’s no run.
- Stays out of the way in the top bar — never overlaps the canvas.
The stats bar’s health number always matches the Overview panel — same calculation. Filter drops (intentional) get tracked separately so a pipeline that filters 80% of items by design can still show a healthy score.
How time works
Section titled “How time works”The simulation clock works in milliseconds with full floating-point precision. You can use any unit you want — picoseconds, nanoseconds, microseconds, milliseconds, seconds, minutes, hours, days, weeks, or years — and the engine carries the real ratios end to end. A design that mixes a 1ns flip-flop, a 5μs PCI hop, and a 20ms network call all on the same canvas keeps each duration honest. Each frame’s time comes from the processing times, line latencies, and behavior delays you set on your blocks.
Total run length (engine drain budget, internal):
drain budget = max(longest path × seed count × 4.0, minimum)The longest path is figured out automatically by walking from every entry block through every line and processing time. So a design with 200ms steps runs on a completely different scale than one with 3-minute batch cycles, and the timeline adapts.
The × 4.0 is a safety multiplier that gives the engine headroom for queueing and jitter; without it, packets entering near the tail of a long path can get stranded and report as phantom drops. It is an engine-internal budget, not what the HUD time chip shows you.
What the HUD time displays
Section titled “What the HUD time displays”The clock chip above the canvas is anchored on the critical path (the longest path through your topology, without the safety multiplier or seed count). So the end-of-sim time reads back the number you’d compute by summing processing times along the slowest route, which is what your inputs actually say. Mid-sim it scales linearly with progress. The 4× drain budget stays where it belongs (engine-internal stability), not in the displayed number.
Time compression
Section titled “Time compression”If the raw run length would go over 1 hour, the engine scales every duration down by the same factor so it fits inside the cap. The ratio is 3,600,000 / raw duration. Because every duration shrinks the same way, the relative shape of bottlenecks doesn’t change. A block that takes 10x longer than another still takes 10x longer after compression.
This means you can use real-world durations (hours, days) on your blocks and the engine will compress them into a runnable simulation without losing the relative timing.
Frames are rate-limited so you don’t see one row per microsecond. Skipped frames carry their data forward into the next emitted frame so nothing gets lost.
What you see on the canvas during playback
Section titled “What you see on the canvas during playback”Line animation
Section titled “Line animation”Active lines show dashed segments flowing in the direction of traffic:
- Active: accent-colored dashes flowing along the line.
- Branch-colored: lines from a decision block are green (true path) or orange (false path) with a percentage badge (“73%”).
- Used before, not now: accent color at 30% opacity.
- Never used: dimmed to 15% with a smooth fade.
Block badges
Section titled “Block badges”During playback, badges stack at the top-right corner of each block (only shown when more than 0):
| Icon | Color | Counter |
|---|---|---|
| ↑ Arrow up | Green | Delivered (running total, exit blocks). |
| ↓ Arrow down | Blue | Entered (running total, entry blocks). |
| Filter | Purple | Filtered (running total, filter-mode blocks only). |
| Skull | Red | Lost (running total, real failures: overflow, throttle, circuit breaker). |
| Layers | Amber | Queued (snapshot at this frame). |
Delivered and entered keep adding up. Queue depth is a live count at the current frame.
Queue heat
Section titled “Queue heat”As a block’s queue fills toward its capacity, it tints warmer (orange to red). The heat is queue depth ÷ capacity.
Queue badge
Section titled “Queue badge”When more than 3 items are waiting, a number shows on the block. The number reflects the actual queue at each frame.
Dimming
Section titled “Dimming”Blocks not involved in the run dim to 30%. Lines with no traffic — past or present — dim to 15%. Both fade smoothly and brighten back up when something happens or you select them.
What’s processing right now
Section titled “What’s processing right now”The block currently processing shows a blue halo at 50% opacity.
Trouble alerts
Section titled “Trouble alerts”Blocks under stress show visual alerts:
- Failure: red flash on the block icon (0.7s).
- Warning / critical: orange or yellow flash (1s).
- Bottleneck: pulsing orange / red border on the saturated block.
Console
Section titled “Console”Press ` to open the console while a run plays. You’ll see timestamped logs. Every frame produces:
- A headline: “flow step N: blocks A, B, C (X items in flight)”.
- Lines for each drop, error, and routing decision.
The console keeps the last 300 entries so it stays snappy during long runs.
GIF export
Section titled “GIF export”Export the whole playback as an animated GIF from the Export modal’s GIF tab. Pick a speed (1x, 2x, 4x), pick light or dark, then generate and download. Useful for READMEs, docs, or presentations.