
Worker Visualizer
FreeReal-time particle and simulation visualizer for web applications.
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 source1. Install with the skills CLI
npx skills add nexu-io/open-design/worker-visualizer --agent claude-code2. 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-ioWorker 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
ImageDatabuffer. - 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 adata:URL. - Prefer SharedArrayBuffer for large per-frame state: allocate on the main thread, pass the
SharedArrayBufferto the worker, and read the sameFloat32Array/Uint8ClampedArrayview while drawing. Guard ontypeof SharedArrayBuffer !== 'undefined' && crossOriginIsolated. - Fallback path: if not isolated,
postMessagea transferableArrayBuffereach 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.
-
SharedArrayBufferpath engages whencrossOriginIsolatedis true;postMessagefallback 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
Playwright Component Testing
Test React and Vue components in isolation with Playwright.
Fluent UI Blazor
Integrate Fluent UI components in Blazor applications effortlessly.
Build MCP App
Create interactive UI widgets for MCP servers.
Web Design Reviewer
Identify and fix design issues in websites efficiently.
Markstream Install
Seamlessly integrate Markstream for Markdown rendering.
GSAP & Framer Scroll Animation
Create advanced scroll animations effortlessly.
