SpriteForge Pixel sprite demo
Powered by Spooled
0 jobs
0 done
0 retries
Connecting…

Interactive Spooled demo

Watch a job queue forge a sprite

Hit Forge Sprite and Spooled runs a real workflow — parallel frame jobs, workers with leases, automatic retries, and live events — not a mocked animation.

Live stage Ready

Hit Forge Sprite

Watch Spooled queue → workers → assemble

Forge controls

Frames run in parallel. Chaos shows retries.

8
10%

/Ctrl+Enter

Live pipeline

Jobs · events · scheduled sprite

Pending Running Done Retry
No active jobs — forge to start

Concepts

Understanding Spooled

Not technical? Think of a coffee shop. Each idea below is an everyday analogy, then how it shows up when you hit Forge Sprite.

What is a Job?

Coffee shop A job is your order slip: “latte, oat milk.” It waits until a barista picks it up.

In this demo Forging creates jobs such as “generate frame 3” and one later “assemble” job. Each is a unit of work with a JSON payload.

{
  "queue": "spriteforge-frames",
  "payload": {
    "kind": "frame",
    "frameIndex": 3,
    "seed": "pixel-hero",
    "paletteName": "neon"
  }
}

What is a Queue?

Coffee shop The queue is the line of slips above the machine. Work is claimed in order by available workers.

In this demo Three queues: spriteforge-frames, spriteforge-assemble, and spriteforge-public (scheduled sprites). Separate queues keep fast parallel work off heavier assembly.

What is a Worker?

Coffee shop Workers are the baristas. They pull an order, do the work, and mark it done. More workers usually means more throughput.

In this demo Defaults: 8 frame workers, 2 assemble workers, and 1 public-sprite worker (overridable via env). They claim jobs with leases and heartbeats.

What is a Workflow?

Coffee shop A combo order: brew the coffee and warm the muffin in parallel, then box them only when both are ready.

In this demo N frame jobs run in parallel; the assemble job dependsOn every frame. When all frames complete, assemble runs once.

What are Retries?

Coffee shop Dropped a drink? Make it again. The order is not thrown away — it goes back so someone can finish it.

In this demo The Chaos slider injects random failures on frame jobs. Spooled retries automatically (this forge sets maxRetries: 5 on workflow jobs). Turn Chaos up and watch red → retry → green.

What are Real-time Events?

Coffee shop The board that says “Order #42 ready!” — the shop tells you; you do not keep asking.

In this demo Spooled streams job events over WebSocket to this server, which forwards them to your browser over SSE. A light reconcile poll fills gaps if an event is missed — so the UI stays honest under imperfect networks.

What are Schedules?

Coffee shop Coffee brewed at 6 AM every day without a customer asking — work on a timetable.

In this demo Sprite of the Minute uses cron 0 * * * * * (every minute, UTC) on the spriteforge-public queue. Open the Minute tab to see it update.

How is this secured?

Coffee shop Staff hold the back-room keys. Customers never need them to place an order.

In this demo Your browser talks only to the SpriteForge server. The Spooled API key stays on the server and is never sent to the client. Job payloads are ordinary JSON stored by Spooled — this demo does not claim field-level encryption or compliance certifications.

Try it yourself

  1. Forge Sprite Jobs appear in the Jobs tab; the pipeline steps light up.
  2. Watch status colors Pending → running → done, or fail → retry.
  3. Raise Chaos to 30%+ See automatic retries without rewriting the workflow.
  4. Open Events State changes stream in as they happen (with reconcile as backup).

Context

How would you build this elsewhere?

Same demo needs jobs, a DAG, workers, retries, a schedule, and live visibility. Honest sketches of common stacks — and where each is genuinely stronger. Full matrices live on spooled.cloud/compare.

AWS SQS + Step Functions

  • SQS (or similar) for messages; Step Functions for the DAG
  • Lambda (or ECS) workers; EventBridge for cron
  • API Gateway WebSocket or AppSync if you need browser live updates

Trade-offs: Excellent if you are already deep in AWS. You wire several managed services yourself; Step Functions charges per state transition; browser streaming is not built-in. Great fit for Lambda-native shops.

Redis + BullMQ

  • BullMQ queues and Node workers; optional Bull Board
  • Workflow deps and multi-language workers are mostly your code
  • Repeatable jobs / node-cron; Pub/Sub + your own SSE for the browser

Trade-offs: Outstanding Node DX and low latency. You operate Redis and own durability, multi-tenant platform surface, and polyglot APIs. Prefer BullMQ when the app is one Node codebase and you want a library, not a hosted queue product. Compare →

Temporal

  • Workflows + activities for frames and assemble
  • First-class retries, timeouts, and durable execution history
  • Schedules API; browser streaming still a separate layer

Trade-offs: Best-in-class for complex, long-running business processes and saga-style logic. Heavier programming model and ops than a simple job queue. Prefer Temporal when durable execution is the product; prefer a job queue when most work is “enqueue → claim → complete.” Compare →

Inngest

  • Event-driven functions with step.run for parallel work
  • Built-in retries and cron; serverless-first hosting model
  • Live browser feed usually custom (poll or your own socket)

Trade-offs: Excellent DX for Next.js / serverless teams. Different mental model than pull-based workers with leases. Prefer Inngest when functions-as-steps are natural; prefer worker-first queues when long-running processes pull jobs continuously. Compare →

Why we built Spooled

A job queue that is simple to start with, still useful at scale: durable jobs, workflows without a heavy DSL, schedules, and real-time visibility — cloud or self-host, REST + gRPC, polyglot workers.

  • PostgreSQL as source of truth Jobs live in a real database with normal transactional semantics you can query.
  • Real-time as a product surface Stream job lifecycle events without bolting on a second pub/sub stack for basic dashboards.
  • Worker-first, language-agnostic Pull jobs over REST or gRPC from any runtime — not locked to one language library.
  • Workflows as dependencies Express “assemble after all frames” with job keys and dependsOn, not a new language.
  • Cloud or self-host Same API either way when you need the data path on your own network.

Being honest: Spooled is not always the right tool. Sub-millisecond in-process work is happier in Redis/memory. Deep AWS shops may prefer Step Functions + Lambda integration. Complex multi-week sagas are Temporal’s home turf. Serverless-only teams often prefer Inngest’s function model. If you want a queryable job queue with workers, schedules, and live status you can demo in an afternoon — try Spooled.

spooled.cloud Docs This demo on GitHub