Task grid
One job split into hundreds of small tasks across a pool of workers: a cell per task tinted by status, counts that filter the grid, the cost and time left, each task's card one hover away and Retry failed.
oxyn add task-gridFan-out
Enrich 240 sign-up domains0 / 240$-0.00~26s left0% done.
rsx! {
TaskGrid {
tasks: Some(job.tasks()),
at: Some(job.elapsed_ms()),
workers: 12,
now: clock.now(),
}
}Rendered from Rust at build time · goes live when visible
When to use
- Two related moments: 1.
- Parallel attempts — the user runs the same task N times (N agents, N models, or N git worktrees) and wants to watch them side by side, compare the outputs, and pick a winner.
- Coding agents do this with a worktree per task (Codex app, Conductor, Verdent, Paradev, Emdash, Cursor Agents Window, Copilot — research note 03; agentbox "each agent gets its own git worktree" [R027]). 2.
- Fan-out / map-reduce — one agent hands a big job to many workers (100 files, 40 URLs) and the user wants coverage at a glance: how many done, which failed, what is left.
When not to use
- Who started whom: use Sub-agent tree instead.
- One tool call in one line: use Tool call instead.
- Grey shapes the size of what they stand in for, one sheen sweeping across all of them in step (or a staggered pulse), shown only after a short delay, then a crossfade into the content: use Skeleton instead.
Installation
Task grid is free and MIT. The oxyn CLI copies its code, and the components it needs, into src/oxyn/ of your Dioxus or GPUI project, so it is yours to change.
cargo install --git https://github.com/ismailqureshi72/Oxyn oxyn-cli
oxyn init
oxyn add task-griduse crate::oxyn::{TaskGrid, STATUS_INDICATOR_CSS};Rather depend on the crate? cargo add oxyn-dioxus oxyn-core --git https://github.com/ismailqureshi72/Oxyn, then use oxyn_dioxus::{TaskGrid, STATUS_INDICATOR_CSS};
Usage
rsx! {
TaskGrid {
tasks: Some(job.tasks()),
at: Some(job.elapsed_ms()),
workers: 12,
now: clock.now(),
}
}Examples
Live
The job replays and loops: cells turn blue with a shine, then green in a wave; one retries in amber, two fail; done, cost and time left keep moving.
Fan-out
Enrich 240 sign-up domains0 / 240$-0.00~26s left0% done.
Code
rsx! {
TaskGrid {
tasks: Some(job.tasks()),
at: Some(job.elapsed_ms()),
workers: 12,
now: clock.now(),
}
}Early
Three seconds in: the first wave of twelve workers busy, everything else queued.
Fan-out
Enrich 240 sign-up domains20 / 240$0.30~23s left0% done.
Code
rsx! {
TaskGrid {
tasks: Some(job.tasks()),
at: Some(job.elapsed_ms()),
workers: 12,
now: clock.now(),
}
}Mid
Mid-job: green spreading, a retry breathing amber, the time left counting down.
Fan-out
Enrich 240 sign-up domains91 / 240$1.36~16s left30% done.
Code
rsx! {
TaskGrid {
tasks: Some(job.tasks()),
at: Some(job.elapsed_ms()),
workers: 12,
now: clock.now(),
}
}Filtered
A count pressed: only running cells stay vivid, the rest fade back.
Fan-out
Enrich 240 sign-up domains91 / 240$1.36~16s left30% done.
Code
rsx! {
TaskGrid {
tasks: Some(job.tasks()),
at: Some(job.elapsed_ms()),
workers: 12,
now: clock.now(),
}
}Pinned
A cell pinned: a ring on it and its card – worker, time, tries, cost and result.
Fan-out
Enrich 240 sign-up domains91 / 240$1.36~16s left30% done.
Code
rsx! {
TaskGrid {
tasks: Some(job.tasks()),
at: Some(job.elapsed_ms()),
workers: 12,
now: clock.now(),
}
}Failed
Ended with two failures: a red count and Retry failed, which runs them again until the job finishes green.
Fan-out
Enrich 240 sign-up domains238 / 240$3.522 failedFinished: 238 done, 2 failed, $3.52.
Code
rsx! {
TaskGrid {
tasks: Some(job.tasks()),
at: Some(job.elapsed_ms()),
workers: 12,
now: clock.now(),
}
}Narrow
Below 520 px the cells get smaller and done / cost / time left wrap under the title.
Fan-out
Enrich 240 sign-up domains91 / 240$1.36~16s left30% done.
Code
rsx! {
TaskGrid {
tasks: Some(job.tasks()),
at: Some(job.elapsed_ms()),
workers: 12,
now: clock.now(),
}
}Classic
Classic style: square-ish cells; the count buttons sit in a grey strip along the bottom of the card.
Fan-out
Enrich 240 sign-up domains238 / 240$3.522 failedFinished: 238 done, 2 failed, $3.52.
Code
rsx! {
TaskGrid {
tasks: Some(job.tasks()),
at: Some(job.elapsed_ms()),
workers: 12,
now: clock.now(),
}
}API reference
TaskGrid
| Prop | Type | Default | Description |
|---|---|---|---|
tasks | Option<Vec<FoTask>> | Default::default() | The tasks (the demo's 240 when `None`). |
at | Option<u32> | Default::default() | Ms into the job; `None` replays the demo (looping). |
workers | u32 | 12 | Workers (for the estimate). |
job | String | "Enrich 240 sign-up domains" | The job line. |
title | String | "Fan-out" | Heading. |
filter | Option<FoStatus> | Default::default() | A status filter from the start. |
pinned | Option<usize> | Default::default() | A task pinned from the start (index). |
nowrequired | ClockMs | — | The clock (drives the replay). |
style | String | Default::default() | `clean`, `classic`, or empty to follow `data-cstyle`. |
on_retry | EventHandler<Vec<String>> | — | Retry failed was pressed (the failed task ids). |
on_select | EventHandler<Option<usize>> | — | A task was pinned (index) or released. |
Read from the Rust signature and doc comments.
Keyboard interactions
| Key | Action |
|---|---|
| Tab | The grid is one stop, then the counts and Retry failed |
| Arrow keysorHomeorEnd | Walk the cells and show each one's card |
| EnterorSpace | Pin or release the card |
| Escape | Releases the card |
Accessibility
- The grid is a single tab stop with an active cell; each cell is named by its task and status and described by its card.
- Each count is a pressed / not-pressed toggle; a polite status line reports progress every tenth and once at the end.
- Status is never colour alone: the card and the counts say it in words; reduced motion stops the wave, shine and breathing.
From the spec
columnsis agrouplabelled "3 parallel attempts"; each lane is aregionlabelled "Attempt B, Sonnet, needs approval". Cells grid usesgridwithgridcells ("Task 37, failed, attempt 2"); arrow keys move by cell, Page Up/Down by row.- Live region (polite): attempt finished ("Attempt C done in 2 minutes 4 seconds, 14 of 14 tests passing"), attempt needs you (assertive), fan-out milestones at 25 / 50 / 75 / 100 % and on each new failure batch (max one per 5 s), winner chosen, undo available.
- Contrast: state cells use tone + glyph at ≥ 12 px (✓ ✕ ↻); below 12 px, a pattern (hatched for failed, dotted for retrying) in addition to colour; text ≥ 4.5:1, swatches ≥ 3:1.
- Focus order: header (Compare, Layout, Stop all) → lanes left → right (each: header, body, actions) → confirm sheet traps focus while open and returns it to the Pick button.
- Keyboard:
1–9focus lane n (when the grid has focus),ppick,ccompare,uundo, Esc closes compare/sheet. All have visible hints in tooltips. - Reduced motion: §5 last row; inbox column changes are also announced.
Motion & interaction
- Dispatch. Lanes slide in from the dispatch origin (the composer or the parent row) left → right, y +8 → 0, 40 ms stagger (cap 6); bodies start as skeletons (skeletons.md) sharing one viewport-pinned sweep.
- Live tail. New lines push up inside a 6-line window with a 12 px top fade mask; no scroll jank (fixed line height).
- Scorecard numbers. Diff stat and test counts roll (odometer, 280 ms); tests fill a tick row one tick per test [R037].
- Needs you. Lane header turns amber with the static waiting glyph; the grid header count rolls; in the inbox the card glides to NEEDS YOU (FLIP move, 260 ms
ease.in-out) [R062]. - Lane finishes first. A single 400 ms outline pulse in success tone on the lane frame (no confetti); the header shows "1st" rank chip only if the app asks for finish order.
- Compare. Pick lane A, then B: the two lanes slide together (others dim to 50 %) and the body morphs into a split diff; Esc slides them back.
- Pick winner. Pressing Pick ★ lifts the lane (scale 1.02, shadow) and opens the confirm sheet; on confirm the winner widens to full width with
spring.snapwhile the others collapse to stubs and fade to 40 %, 40 ms stagger outward from the winner. Undo reverses within 8 s (not available after delete). - Cells. A cell fills from centre (scale 0.6 → 1) when its task completes; failures flash danger then hold; retries draw a ring around the cell; the header counter rolls. Hover shows a tooltip card (task label, worker, elapsed, tokens, error line).
- Hand-offs (Pro
swimlanes): a curved connector draws from one lane's block to another's over 300 ms when work passes between agents. - Hover / focus. Lane frame gets the focus ring; header reveals stop and focus; the lane minimap highlights the hovered lane.
Timing
| Transition | Duration | Delay | Easing / spring | Stagger | Frame rate |
|---|---|---|---|---|---|
| Lane enter | 220 ms, y +8 → 0 | — | ease.out | 40 ms, cap 6 | 60 Hz |
| Skeleton sweep | loop.sweep 2.0 s | — | linear | shared | 30 Hz |
| Live tail line push | 120 ms | — | ease.out | — | 60 Hz |
| Scorecard digit roll | 280 ms | — | ease.out | 30 ms right → left | 30 Hz |
| Test tick fill | 120 ms | — | ease.out | 60 ms | 30 Hz |
| Inbox card glide (FLIP) | 260 ms | — | ease.in-out | 40 ms when several | 60 Hz |
| First-finish pulse | 400 ms × 1 | — | ease.out | — | 60 Hz |
| Compare slide together | 240 ms | — | ease.in-out | — | 60 Hz |
| Pick lift | 120 ms | — | spring.snap | — | 60 Hz |
| Winner widen / losers collapse | 260 ms / 200 ms | — | spring.snap | 40 ms outward | 60 Hz |
| Undo window | 8 s | — | — | — | — |
| Cell fill | 160 ms, scale 0.6 → 1 | — | spring.snap | 10 ms within a batch, cap 20 | 60 Hz |
| Cell failure flash | 200 ms | — | ease.out | — | 60 Hz |
| Hand-off connector draw | 300 ms | — | ease.out | — | 60 Hz |
| Header count roll | 280 ms | — | ease.out | — | 30 Hz |
| Reduced motion | lanes and cards appear in place with 80 ms crossfade; inbox cards change column without gliding (column count text updates); no lift, widen or collapse animation (layout switches on the next frame with 80 ms fade); cells change colour instantly; no pulses; digits swap | — | linear | none | 1 Hz for clocks |
Responsive behaviour
- The cells fill the width and wrap.
- Below 520 px cells are 8 px and the header figures wrap onto their own line.
Edge cases (spec)
- N = 1. Renders as a single lane without Compare; Pick hidden.
- N large (parallel attempts > 16). Horizontal scroll + minimap; auto-suggest
cells; Compare limited to two lanes at a time. - Fan-out > 1 000 tasks. Cells group into blocks of 100 with a fill level; drilling in shows the block. Only visible cells repaint; the header counters are the truth.
- Unequal lanes. Lanes have equal width by default; a focused lane can expand to 2× while others shrink to a minimum of 220 px.
- Pick while some lanes still run. Confirm sheet adds "Stop 2 running attempts"; default stops them.
- Delete worktrees. Destructive: the sheet names the worktrees/branches and requires a second press (or typing the count for > 5); undo is not offered after delete.
- Winner apply fails. Lane goes
MergeFailed; other lanes are restored from Archived if they were archived in the same action (if the app supports it). - Identical outputs. Compare shows "No differences" with the shared diff stat; both stay pickable.
- No scorecard data. Scorecard row hidden (never "0 tests").
- Long labels. Lane label 20 ch, model 16 ch, workspace chip truncates middle.
- RTL. Lane order mirrors (first attempt on the right); diff stats, numbers and code stay LTR.
- Tiny sizes. Under 480 px wide,
columnsbecomes a vertical list of lane headers (accordion); cells stay at ≥ 8 px with a 2 px gap. - Dense IDE panels. Headers only (28 px), bodies hidden until focused.
- Touch. Lanes swipe horizontally with snap; Pick requires press-and-hold 400 ms or the sheet.
- Slow networks. Lanes keep last tail; an offline banner pauses clocks' liveness styling, not the clocks themselves (elapsed-timer.md §2).
- Very fast lanes. A lane finishing within
show_delay(150 ms) appears directly as Done.
Notes for AI
- Import
TaskGridfromoxyn_dioxusand includeSTATUS_INDICATOR_CSSplus the token stylesheet once. - A GPUI version exists:
TaskGridElinoxyn_gpui. - Props to set first:
now. - It reads a clock (
now) for live timers; pass one clock for the whole page rather than one per component. - Keep its states and timings as they ship; restyle it through the CSS variables rather than by hand.