New to Claude Skills? Learn how to install them →

nexu-io on GitHub

Worker Visualizer

Free

Real-time particle and simulation visualizer for web applications.

by nexu-io84.9k stars on nexu-io/open-design
1 views
Updated Aug 10, 2026
Get this skill

Free · Opens the source repo

What Worker Visualizer does

The Worker Visualizer is a specialized tool designed for developers needing to offload heavy computational tasks to a Web Worker while maintaining a smooth user experience. By rendering results to a canvas at 60 frames per second, it ensures that the main thread remains responsive, which is crucial for applications involving real-time simulations or visualizations. This skill is particularly beneficial for those working on particle systems, physics simulations, or any application that requires intensive calculations without compromising UI performance.

This skill produces a single self-contained index.html file that encapsulates all necessary code, including the Web Worker. The implementation leverages SharedArrayBuffer for efficient memory sharing between the worker and the main thread, allowing for zero-copy data transfers when cross-origin isolation is enabled. If the environment does not support this feature, it falls back to using postMessage with transferable ArrayBuffer, ensuring that the visualizer remains functional regardless of the user's browser settings.

To utilize the Worker Visualizer, developers can choose from several compute-bound tasks, such as simulating a particle field, generating fractals, or visualizing audio data. The workflow is straightforward, beginning with reading an example implementation, selecting a workload, and building the index.html file. The skill also includes guidelines for creating an overlay to display real-time statistics, enhancing the user interface and providing valuable feedback during simulations.

This tool is ideal for web developers and designers who want to create interactive visual experiences without sacrificing performance. It is particularly useful in educational settings, data visualization projects, and any scenario where real-time feedback is essential. With its focus on off-main-thread processing, the Worker Visualizer is a powerful addition to any developer's toolkit.

When to use it

Use this skill when developing applications that require real-time simulations, such as particle systems, fractals, or audio visualizations, and need to maintain a smooth user interface.

When not to use it

This skill may not be suitable for applications that do not require heavy computations or where real-time performance is not critical.

What you can build with it

Real-Time Particle Simulation

Create a dynamic particle system that updates thousands of particles in real-time while keeping the UI responsive.

Fractal Generation

Generate and visualize complex fractals like the Mandelbrot set, allowing users to explore intricate patterns interactively.

Audio Visualization

Transform audio streams into real-time visual representations, such as bars or rings, enhancing multimedia applications.

How to install Worker Visualizer

View source

1. Install with the skills CLI

npx skills add nexu-io/open-design/worker-visualizer --agent claude-code

2. Or install it manually

Download the skill folder and drop it into ~/.claude/skills/ for all projects, or .claude/skills/ to scope it to one repo. Restart Claude Code so it picks up the new skill.

Anthropic's agentic coding CLI, and the reference implementation of Agent Skills. Drop a skill folder into ~/.claude/skills and Claude Code loads it automatically whenever a task matches the skill's description. Claude Code docs

Inside SKILL.md

Written by nexu-io

Worker Visualizer Skill

Produce a single self-contained index.html that moves heavy per-frame compute into a Web Worker and renders the result to a canvas, keeping the main thread at a smooth 60fps.

Why this is a powered artifact

Open Design detects new Worker( / SharedArrayBuffer / OffscreenCanvas and renders this file in powered preview — a cross-origin-isolated iframe with allow-same-origin. That means external and blob Web Workers construct successfully, SharedArrayBuffer is defined (crossOriginIsolated === true), and importScripts works. In the old opaque sandbox all three failed; here they just work.

Resource map

worker-visualizer/
├── SKILL.md      ← you're reading this
└── example.html  ← a working 12k-particle SharedArrayBuffer sim (READ FIRST)

Workflow

Step 0 — Read the reference

Read example.html. Note the split: the worker integrates positions each tick; the main thread only reads + draws. It feature-detects crossOriginIsolated and uses a SharedArrayBuffer for zero-copy when available, falling back to a transferable postMessage copy otherwise. Always ship that fallback so the artifact still animates if isolation is off.

Step 1 — Choose the workload

Pick ONE compute-bound job worth offloading:

  • Particle / N-body field (default): thousands of bodies with a cheap force law.
  • Fractal: Mandelbrot/Julia escape-time into an ImageData buffer.
  • Cellular automata / reaction-diffusion: grid updated in the worker.
  • Data/audio visualizer: transform a stream into bars/rings each frame.

Step 2 — Build index.html

  • One file, zero external requests. Build the worker from a Blob + URL.createObjectURL (inline its source), or embed it as a data: URL.
  • Prefer SharedArrayBuffer for large per-frame state: allocate on the main thread, pass the SharedArrayBuffer to the worker, and read the same Float32Array/Uint8ClampedArray view while drawing. Guard on typeof SharedArrayBuffer !== 'undefined' && crossOriginIsolated.
  • Fallback path: if not isolated, postMessage a transferable ArrayBuffer each frame.
  • Consider OffscreenCanvas + canvas.transferControlToOffscreen() to render inside the worker for the heaviest scenes.

Step 3 — Overlay + brand

  • HUD with the title and 2–3 live stat tiles (particle count, transport mode, fps). Map accent color to the active DESIGN.md when present; otherwise a dark ground with one vivid accent.

Step 4 — Self-review (P0)

  • Worker constructs with no SecurityError; sim runs.
  • Main-thread render holds ~60fps under the full workload.
  • SharedArrayBuffer path engages when crossOriginIsolated is true; postMessage fallback engages otherwise — verify BOTH branches degrade cleanly.
  • No unbounded growth: velocities/positions stay stable over minutes.
  • The "Transport" stat truthfully reports which path is live.

Frequently asked questions about Worker Visualizer

Similar skills