Junkpile developer guide
Junkpile gives you runnable desktop projects for common creative-media problems—rendering, camera and video input, audio, MIDI and OSC, recording, GPU processing, export, and output routing. Use the smallest example that already solves part of your problem, understand its boundaries, then adapt or combine it into your own application.
Junkpile removes repeated setup work from creative desktop development. Instead of starting with an empty Tauri project and rebuilding graphics, media input, recording, control, and output plumbing yourself, you can begin with a working example that already owns the part of the application you need.
The examples are meant to be run, read, modified, and combined. They range from approachable WebView/WebGL projects to native Rust/wgpu projects for workloads that need more direct GPU or media control.
Tauri v1 and v2 package the project as a desktop application and determine configuration, permissions, plugins, window APIs, IPC conventions, and some window-integration constraints.
WebView/WebGL is the more accessible browser-style path. Native Rust/wgpu gives Rust direct ownership of pixels, textures, the render loop, and GPU resources when the application needs that control.
Camera, audio, files, MIDI, OSC, FFmpeg, NDI, Syphon, Spout, and other services connect the application to media, controllers, recorders, and external systems. They are integration layers, not synonyms for one renderer.
The fastest way into Junkpile is to find the example closest to your goal and prove that it works unchanged. That gives you a known-good baseline before your own code enters the picture.
npm install once for the project.npm run dev.git clone https://github.com/schwwaaa/junkpile.git
cd junkpile/wgpu/43-wgpu-av-recorder
npm install
npm run devgit --version
node --version
npm --version
rustc --version
cargo --versionxcode-select --installNative wgpu uses Metal. Camera/microphone projects require OS permissions. Syphon is macOS-specific.
Install Visual Studio Build Tools with Desktop development with C++, WebView2, and current GPU drivers. Spout projects have additional native build/runtime requirements.
Install the distribution's Tauri/WebKitGTK development packages and a functional Vulkan or supported GPU driver stack.
cd <project-folder>
npm install
npm run buildTypical bundles appear beneath src-tauri/target/release/bundle/. Signing/notarization requirements depend on platform and distribution method.
ffmpeg and ffprobe. NDI-enabled builds require the NDI SDK/runtime.Do not choose a track because one sounds more advanced. Choose it based on what your application actually needs. WebView projects are often faster to understand and modify; native wgpu becomes useful when direct GPU ownership, compute, high-resolution rendering, or tighter native-media integration matters.
| Need | Current Junkpile starting point |
|---|---|
| p5.js / browser-media experimentation | Tauri v1 or v2 WebView |
| Current Tauri permissions, dialogs, window APIs | Tauri v2 WebView |
| Explicit GPU resources / compute | Native wgpu |
| Current high-resolution native render/record references | Native wgpu series |
| Current dedicated NDI / Syphon / Spout sender references | Native wgpu I/O series; the transports themselves are not wgpu-only |
| Fast creative application parity | Compare the WebView example with its native counterpart where one exists |
The tracks can produce similar kinds of applications, but they place responsibility in different places. This table shows what you take ownership of when moving from a WebView renderer toward native wgpu.
| Concern | Tauri v1 WebView | Tauri v2 WebView | Tauri 2 + native wgpu |
|---|---|---|---|
| Pixel owner in current examples | WebView | WebView | Rust/wgpu surface |
| Shader language in current examples | GLSL ES | GLSL ES | WGSL |
| Animation/render loop | JavaScript / p5 | JavaScript / p5 | Rust |
| GPU resources | WebGL objects in JS | WebGL objects in JS | wgpu textures/buffers/pipelines in Rust |
| Compute in repository baselines | Not demonstrated by the WebGL 1 baselines | Not demonstrated by the WebGL 1 baselines | First-class in the current wgpu examples |
| Native services / media bridges | Rust bridge when an example needs one | Rust bridge when an example needs one | Rust-owned and commonly integrated directly with renderer state |
| Recording examples | Browser/canvas recording exists | Browser/canvas recording exists | Current native FFmpeg/high-resolution/A/V recording lineage |
| NDI / Syphon / Spout | No dedicated sender example in current v1 tree | No dedicated sender example in current v2 tree | Current dedicated Junkpile sender/router references |
A creative application usually needs more than a shader. Junkpile separates input, state, rendering, and output so you can reuse the pieces you need without adopting one giant application framework.
The repository is intentionally product-agnostic. Proven patterns can be reused by focused applications without requiring one monolithic runtime or one mandatory UI.
When something breaks, it helps to know who owns it. These three diagrams show the main execution boundary in each repository track before native services and external outputs are added.
V1 WebView
V2 WebView
Native wgpu
For the detailed lifecycle/resource model, read ARCHITECTURE.md.
Use the v1 examples when you want a direct, readable WebView/WebGL starting point or need to maintain a Tauri 1 application. The collection covers p5.js, raw WebGL, external GLSL, webcam, feedback, MIDI, OSC, media playback, recording, compositing, projection, sequences, audio-file analysis, and automation.
v1/25-wgpu-ultra-resolution-export. The catalog preserves the actual folder and README rather than pretending it is a WebView project with a different implementation.Use the v2 examples when WebGL or browser media already fits the graphics problem but you want the current Tauri application model for permissions, windows, dialogs, files, IPC, and packaging.
Use the native collection when the application benefits from Rust owning the render loop and GPU resources directly—for example compute workloads, 3D, high-resolution rendering, native video paths, recording, or explicit multi-output routing. The collection also includes application-facing counterparts to several WebView ideas. These are the repository's current implementations; their presence here does not make every attached transport exclusive to wgpu.
Surface, resize, WGSL, controls, textures, feedback, multipass, backend limits.
Camera, FFmpeg video, audio, MIDI, OSC, compositing, glTF, deformation.
Recording, profiles, NDI, Syphon/Spout, routers, appliance runtime, A/V, shader tools.
Once an application has to record, stream, or share frames, the renderer should not wait for every external system to finish its work. The current wgpu I/O series solves that problem with a shared frame contract, bounded workers, and independent output sinks. It is one reusable architecture for a Rust-owned renderer; it is not a statement that the external transports require wgpu.
Authoritative-frame architecture
27 frame/output contract
↓
28 FFmpeg file recording
↓
30 high-resolution recording
↓
31 validated I/O profiles
↓
36 / 39 multi-output routers
↓
43 A/V recorderPreview resolution and output resolution are intentionally independent in the later native projects. A 4K or 8K-class recording is not defined by the visible window size.
wgpu/43-wgpu-av-recorder is the focused starting point when your application needs native video recording with optional audio. It builds on the high-resolution recorder and adds three audio modes: none, microphone, and local audio file, then muxes the finished streams into the final file.
CPAL captures the selected input to a temporary 32-bit float WAV while native video recording runs.
FFmpeg-readable audio can be selected and looped when shorter than the video recording.
On successful mux the intermediate video and temporary microphone file are removed; failures preserve intermediates for diagnosis.
The current router examples show how preview, recording, NDI, Syphon, and Spout can be treated as independent destinations instead of being tangled into one render path. The diagram below describes the current wgpu/ implementations. NDI, Syphon, Spout, and FFmpeg are external/native I/O systems, not wgpu features. A WebView application can still use native Rust/platform integrations, but the handoff from WebView-rendered pixels is a separate application-specific bridge and is not represented by dedicated sender examples in the current v1/v2 folders.
40-wgpu-network-output remains unresolved/under review. Later router/appliance projects intentionally exclude the earlier unresolved network-streaming worker path.macOS-only. Current example bridges wgpu through CPU BGRA staging into a reusable Metal texture and SyphonMetalServer.
Windows-only. Current example bridges wgpu through CPU BGRA staging into a Direct3D 11 shared texture.
Junkpile separates “the source exists” from “this path was actually exercised.” Use these status levels to decide whether an example is a stable starting point, a platform-specific reference, or still research.
| Evidence | Meaning |
|---|---|
| Source present | Project exists in the tree. |
| Static validation | Source/config/metadata checks exist; often documented in VALIDATION.md. |
| Runtime tested | A named platform/device path was actually exercised. |
| Cross-platform tested | Behavior was verified across the targeted operating systems. |
| Unresolved | Project remains useful research but should not be used as a stable baseline. |
Search by capability, technology, or project name. The goal is not to read the repository in order; it is to find the smallest working project that already handles part of your application. The catalog is generated from docs/examples.json, and historical repair copies can remain in the source tree without being treated as separate public examples.
00-p5-tauri-single-template
A focused foundation for running a p5.js WebGL shader and its HTML controls inside one Tauri v1 WebView.
Summary: A focused foundation for running a p5.js WebGL shader and its HTML controls inside one Tauri v1 WebView.
Topology: single-window
Platforms: macOS · Windows · Linux
cd v1/00-p5-tauri-single-template
npm install
npm run dev01-p5-tauri-ws-template
A focused two-window foundation for controlling a p5.js WebGL shader from a separate Tauri v1 WebView through an embedded Rust WebSocket relay.
Summary: A focused two-window foundation for controlling a p5.js WebGL shader from a separate Tauri v1 WebView through an embedded Rust WebSocket relay.
Topology: two-window
Platforms: macOS · Windows · Linux
cd v1/01-p5-tauri-ws-template
npm install
npm run dev02-webgl-tauri-v1-single-template
A focused foundation for running a GLSL ES 1.00 shader through raw WebGL inside one Tauri v1 WebView.
Summary: A focused foundation for running a GLSL ES 1.00 shader through raw WebGL inside one Tauri v1 WebView.
Topology: single-window
Platforms: macOS · Windows · Linux
cd v1/02-webgl-tauri-v1-single-template
npm install
npm run dev03-webgl-tauri-v1-ws-template
A focused two-window foundation for controlling a raw WebGL 1 shader from a separate Tauri v1 WebView through an embedded Rust WebSocket relay.
Summary: A focused two-window foundation for controlling a raw WebGL 1 shader from a separate Tauri v1 WebView through an embedded Rust WebSocket relay.
Topology: two-window
Platforms: macOS · Windows · Linux
cd v1/03-webgl-tauri-v1-ws-template
npm install
npm run dev04-glsl-tauri-v1-single-template
A focused raw-WebGL example where the fragment shader is stored as a real external project file and can be replaced at runtime without rebuilding the Tauri application.
Summary: A focused raw-WebGL example where the fragment shader is stored as a real external project file and can be replaced at runtime without rebuilding the Tauri application.
Topology: single-window
Platforms: macOS · Windows · Linux
cd v1/04-glsl-tauri-v1-single-template
npm install
npm run dev05-glsl-tauri-v1-ws-template
A two-window raw-WebGL example where the fragment shader is stored as an external project file, selected from the controls window, sent through an embedded Rust WebSocket relay, and compiled in a separate output WebView.
Summary: A two-window raw-WebGL example where the fragment shader is stored as an external project file, selected from the controls window, sent through an embedded Rust WebSocket relay, and compiled in a separate output WebView.
Topology: two-window
Platforms: macOS · Windows · Linux
cd v1/05-glsl-tauri-v1-ws-template
npm install
npm run dev06-webcam-tauri-v1-single-template
A focused foundation for capturing a webcam inside a Tauri v1 WebView and uploading each decoded frame into a raw WebGL texture.
Summary: A focused foundation for capturing a webcam inside a Tauri v1 WebView and uploading each decoded frame into a raw WebGL texture.
Topology: single-window
Platforms: macOS · Windows · Linux
cd v1/06-webcam-tauri-v1-single-template
npm install
npm run dev07-webcam-tauri-v1-ws-template
A two-window Tauri v1 example that keeps HTML controls separate from live camera capture and raw WebGL rendering.
Summary: A two-window Tauri v1 example that keeps HTML controls separate from live camera capture and raw WebGL rendering.
Topology: two-window
Platforms: macOS · Windows · Linux
cd v1/07-webcam-tauri-v1-ws-template
npm install
npm run dev08-feedback-tauri-v1-single-template
A focused foundation for persistent GPU feedback inside one Tauri v1 WebView. A webcam or generated source is injected into a pair of alternating WebGL framebuffer textures, allowing each frame to read and transform the previous one.
Summary: A focused foundation for persistent GPU feedback inside one Tauri v1 WebView. A webcam or generated source is injected into a pair of alternating WebGL framebuffer textures, allowing each frame to read and transform the previous one.
Topology: single-window
Platforms: macOS · Windows · Linux
cd v1/08-feedback-tauri-v1-single-template
npm install
npm run dev09-feedback-tauri-v1-ws-template
A modernized two-window Tauri v1 example demonstrating webcam-driven raw WebGL feedback over an embedded Rust WebSocket relay.
Summary: A modernized two-window Tauri v1 example demonstrating webcam-driven raw WebGL feedback over an embedded Rust WebSocket relay.
Topology: two-window
Platforms: macOS · Windows · Linux
cd v1/09-feedback-tauri-v1-ws-template
npm install
npm run dev10-p5-tauri-midi-template
A modernized Junkpile foundation for receiving native MIDI through Rust and using it to control a p5.js WebGL shader inside one Tauri v1 window.
Summary: A modernized Junkpile foundation for receiving native MIDI through Rust and using it to control a p5.js WebGL shader inside one Tauri v1 window.
Topology: single-window
Platforms: macOS · Windows · Linux
cd v1/10-p5-tauri-midi-template
npm install
npm run dev11-p5-tauri-osc-template
A modernized Junkpile essential demonstrating how a Tauri v1 Rust backend can receive Open Sound Control messages over UDP and route them into a p5.js WebGL shader instrument.
Summary: A modernized Junkpile essential demonstrating how a Tauri v1 Rust backend can receive Open Sound Control messages over UDP and route them into a p5.js WebGL shader instrument.
Topology: single-window
Platforms: macOS · Windows · Linux
cd v1/11-p5-tauri-osc-template
npm install
npm run dev12-tauri-v1-video-texture-player
A standalone Tauri v1 application that loads a local video file, uploads each decoded frame to a WebGL texture, processes it with GLSL ES, and displays the result in real time.
Summary: A standalone Tauri v1 application that loads a local video file, uploads each decoded frame to a WebGL texture, processes it with GLSL ES, and displays the result in real time.
Topology: single-window
Platforms: macOS · Windows · Linux
cd v1/12-tauri-v1-video-texture-player
npm install
npm run dev13-tauri-v1-audio-reactive-fft
A focused Tauri v1 essential showing how live microphone audio can drive raw WebGL graphics without a native Rust audio dependency.
Summary: A focused Tauri v1 essential showing how live microphone audio can drive raw WebGL graphics without a native Rust audio dependency.
Topology: single-window
Platforms: macOS · Windows · Linux
cd v1/13-tauri-v1-audio-reactive-fft
npm install
npm run dev14-tauri-v1-canvas-recorder
A standalone Tauri v1 example that records a live WebGL canvas with the browser MediaRecorder pipeline and saves the resulting video through Tauri's native file dialog.
Summary: A standalone Tauri v1 example that records a live WebGL canvas with the browser MediaRecorder pipeline and saves the resulting video through Tauri's native file dialog.
Topology: single-window
Platforms: macOS · Windows · Linux
cd v1/14-tauri-v1-canvas-recorder
npm install
npm run dev15-tauri-v1-multipass-compositor
A standalone Tauri v1 + raw WebGL 1 example demonstrating a reusable multipass post-processing architecture.
Summary: A standalone Tauri v1 + raw WebGL 1 example demonstrating a reusable multipass post-processing architecture.
Topology: single-window
Platforms: macOS · Windows · Linux
cd v1/15-tauri-v1-multipass-compositor
npm install
npm run dev16-tauri-v1-image-texture-processor
A standalone Tauri v1 + raw WebGL 1 example for loading a still image into a GPU texture, processing it in a fragment shader, comparing the original and processed versions, and exporting the result through a native save dialog.
Summary: A standalone Tauri v1 + raw WebGL 1 example for loading a still image into a GPU texture, processing it in a fragment shader, comparing the original and processed versions, and exporting the result through a native save dialog.
Topology: single-window
Platforms: macOS · Windows · Linux
cd v1/16-tauri-v1-image-texture-processor
npm install
npm run dev17-tauri-v1-glsl-shader-playground
A standalone Tauri v1 + raw WebGL 1 example for editing complete fragment shaders, compiling them live, inspecting diagnostics, controlling shared uniforms, saving shader files, and exporting PNG snapshots.
Summary: A standalone Tauri v1 + raw WebGL 1 example for editing complete fragment shaders, compiling them live, inspecting diagnostics, controlling shared uniforms, saving shader files, and exporting PNG snapshots.
Topology: single-window
Platforms: macOS · Windows · Linux
cd v1/17-tauri-v1-glsl-shader-playground
npm install
npm run dev18-tauri-v1-texture-mixer
A standalone Tauri v1 + raw WebGL example for compositing two independent image or video sources in one fragment-shader pass.
Summary: A standalone Tauri v1 + raw WebGL example for compositing two independent image or video sources in one fragment-shader pass.
Topology: single-window
Platforms: macOS · Windows · Linux
cd v1/18-tauri-v1-texture-mixer
npm install
npm run dev19-tauri-v1-webcam-compositor
A standalone Tauri v1 + raw WebGL 1 example for combining a live webcam with keyed background replacement, graphics overlays, recording, and native file export.
Summary: A standalone Tauri v1 + raw WebGL 1 example for combining a live webcam with keyed background replacement, graphics overlays, recording, and native file export.
Topology: single-window
Platforms: macOS · Windows · Linux
cd v1/19-tauri-v1-webcam-compositor
npm install
npm run dev20-tauri-v1-live-video-switcher-speed
A standalone Tauri v1 + raw WebGL example that turns four reusable media slots into a compact software video switcher. Each source can be a generated test pattern, still image, looping video, or the shared live camera. Preview and Program buses feed GPU transitions, a lower-third/logo overlay, MediaRecorder capture, and PNG export.
Summary: A standalone Tauri v1 + raw WebGL example that turns four reusable media slots into a compact software video switcher. Each source can be a generated test pattern, still image, looping video, or the shared live camera. Preview and Program buses feed GPU transitions, a lower-third/logo overlay, MediaRecorder capture, and PNG export.
Topology: single-window
Platforms: macOS · Windows · Linux
cd v1/20-tauri-v1-live-video-switcher-speed
npm install
npm run dev21-tauri-v1-projection-mapper
A standalone two-window projection-mapping foundation built with Tauri v1 and raw WebGL 1.
Summary: A standalone two-window projection-mapping foundation built with Tauri v1 and raw WebGL 1.
Topology: two-window
Platforms: macOS · Windows · Linux
cd v1/21-tauri-v1-projection-mapper
npm install
npm run dev22-tauri-v1-image-sequence-player
A two-window Tauri v1 example for playing numbered still-image sequences as time-based media. The controls WebView handles folder/file selection and transport; the output WebView owns WebGL rendering, decoding, caching, display placement, and PNG capture.
Summary: A two-window Tauri v1 example for playing numbered still-image sequences as time-based media. The controls WebView handles folder/file selection and transport; the output WebView owns WebGL rendering, decoding, caching, display placement, and PNG capture.
Topology: two-window
Platforms: macOS · Windows · Linux
cd v1/22-tauri-v1-image-sequence-player
npm install
npm run dev23-tauri-v1-audio-file-fft-visualizer
A standalone Tauri v1 example that turns a local audio file into a GPU-driven visual performance and recording source.
Summary: A standalone Tauri v1 example that turns a local audio file into a GPU-driven visual performance and recording source.
Topology: single-window
Platforms: macOS · Windows · Linux
cd v1/23-tauri-v1-audio-file-fft-visualizer
npm install
npm run dev24-tauri-v1-keyframe-automation
A standalone Tauri v1/WebGL example for animating visual parameters on an editable timeline.
Summary: A standalone Tauri v1/WebGL example for animating visual parameters on an editable timeline.
Topology: single-window
Platforms: macOS · Windows · Linux
cd v1/24-tauri-v1-keyframe-automation
npm install
npm run dev25-wgpu-ultra-resolution-export
A standalone Tauri 2 + wgpu example for rendering resolution-independent GPU artwork and exporting it as tiled 4K, 6K, 8K, or square PNG files.
Summary: A standalone Tauri 2 + wgpu example for rendering resolution-independent GPU artwork and exporting it as tiled 4K, 6K, 8K, or square PNG files.
Topology: native-window
Platforms: macOS · Windows · Linux
cd v1/25-wgpu-ultra-resolution-export
npm install
npm run dev00-p5-tauri-v2-single-template
A focused foundation for running a p5.js WebGL shader and its HTML controls inside one Tauri v2 WebView.
Summary: A focused foundation for running a p5.js WebGL shader and its HTML controls inside one Tauri v2 WebView.
Topology: single-window
Platforms: macOS · Windows · Linux
cd v2/00-p5-tauri-v2-single-template
npm install
npm run dev01-p5-tauri-v2-ws-template
A focused two-window foundation for controlling a p5.js WebGL shader from a separate Tauri v2 WebView through an embedded Rust WebSocket relay.
Summary: A focused two-window foundation for controlling a p5.js WebGL shader from a separate Tauri v2 WebView through an embedded Rust WebSocket relay.
Topology: two-window
Platforms: macOS · Windows · Linux
cd v2/01-p5-tauri-v2-ws-template
npm install
npm run dev02-webgl-tauri-v2-single-template
This example exposes the complete browser-side WebGL rendering path without p5.js or another graphics framework. It shows how to:
Summary: This example exposes the complete browser-side WebGL rendering path without p5.js or another graphics framework. It shows how to:
Topology: single-window
Platforms: macOS · Windows · Linux
cd v2/02-webgl-tauri-v2-single-template
npm install
npm run dev03-webgl-tauri-v2-ws-template
This example separates a raw WebGL renderer from its user interface while keeping the complete graphics pipeline visible. It shows how to:
Summary: This example separates a raw WebGL renderer from its user interface while keeping the complete graphics pipeline visible. It shows how to:
Topology: two-window
Platforms: macOS · Windows · Linux
cd v2/03-webgl-tauri-v2-ws-template
npm install
npm run dev04-glsl-tauri-v2-single-template
This example extends the explicit raw WebGL pipeline from Example 02 by moving the fragment shader into a real external file. It demonstrates how to:
Summary: This example extends the explicit raw WebGL pipeline from Example 02 by moving the fragment shader into a real external file. It demonstrates how to:
Topology: single-window
Platforms: macOS · Windows · Linux
cd v2/04-glsl-tauri-v2-single-template
npm install
npm run dev05-glsl-tauri-v2-ws-template
This example adds external fragment-shader transport to the two-window raw WebGL architecture. It shows how to:
Summary: This example adds external fragment-shader transport to the two-window raw WebGL architecture. It shows how to:
Topology: two-window
Platforms: macOS · Windows · Linux
cd v2/05-glsl-tauri-v2-ws-template
npm install
npm run dev06-webcam-tauri-v2-single-template
Example 06 connects a browser-managed camera stream to an explicit raw WebGL pipeline. It demonstrates how to:
Summary: Example 06 connects a browser-managed camera stream to an explicit raw WebGL pipeline. It demonstrates how to:
Topology: single-window
Platforms: macOS · Windows · Linux
cd v2/06-webcam-tauri-v2-single-template
npm install
npm run dev07-webcam-tauri-v2-ws-template
Example 07 separates camera control from camera ownership.
Summary: Example 07 separates camera control from camera ownership.
Topology: two-window
Platforms: macOS · Windows · Linux
cd v2/07-webcam-tauri-v2-ws-template
npm install
npm run dev08-feedback-tauri-v2-single-template
Example 08 is a focused study of persistent GPU feedback driven by a live camera texture. It demonstrates how to:
Summary: Example 08 is a focused study of persistent GPU feedback driven by a live camera texture. It demonstrates how to:
Topology: single-window
Platforms: macOS · Windows · Linux
cd v2/08-feedback-tauri-v2-single-template
npm install
npm run dev09-feedback-tauri-v2-ws-template
Example 09 combines the persistent GPU-feedback lesson from Example 08 with a two-window control architecture. It demonstrates how to:
Summary: Example 09 combines the persistent GPU-feedback lesson from Example 08 with a two-window control architecture. It demonstrates how to:
Topology: two-window
Platforms: macOS · Windows · Linux
cd v2/09-feedback-tauri-v2-ws-template
npm install
npm run dev10-tauri-v2-midi-input
A standalone Tauri v2 example showing how native MIDI input can be received in Rust with midir, emitted into a vanilla JavaScript frontend, mapped with MIDI learn, and used to control a raw WebGL visual.
Summary: A standalone Tauri v2 example showing how native MIDI input can be received in Rust with midir, emitted into a vanilla JavaScript frontend, mapped with MIDI learn, and used to control a raw WebGL visual.
Topology: single-window
Platforms: macOS · Windows · Linux
cd v2/10-tauri-v2-midi-input
npm install
npm run dev11-tauri-v2-osc-input
A standalone Tauri v2 example showing how Rust can own an OSC-over-UDP listener, decode messages and bundles with rosc, emit structured events into JavaScript, and route OSC addresses into raw WebGL parameters.
Summary: A standalone Tauri v2 example showing how Rust can own an OSC-over-UDP listener, decode messages and bundles with rosc, emit structured events into JavaScript, and route OSC addresses into raw WebGL parameters.
Topology: single-window
Platforms: macOS · Windows · Linux
cd v2/11-tauri-v2-osc-input
npm install
npm run dev12-tauri-v2-video-texture-player
A standalone Tauri v2 example for loading local video, decoding it in the WebView, uploading newly presented frames into a WebGL texture, applying GLSL processing, retaining temporal feedback, and exporting PNG snapshots.
Summary: A standalone Tauri v2 example for loading local video, decoding it in the WebView, uploading newly presented frames into a WebGL texture, applying GLSL processing, retaining temporal feedback, and exporting PNG snapshots.
Topology: single-window
Platforms: macOS · Windows · Linux
cd v2/12-tauri-v2-video-texture-player
npm install
npm run dev13-tauri-v2-audio-reactive-fft
A microphone-driven Web Audio and raw WebGL example for the Junkpile Tauri v2 essentials collection.
Summary: A microphone-driven Web Audio and raw WebGL example for the Junkpile Tauri v2 essentials collection.
Topology: single-window
Platforms: macOS · Windows · Linux
cd v2/13-tauri-v2-audio-reactive-fft
npm install
npm run dev14-tauri-v2-canvas-recorder
A standalone Tauri v2 example that records a live WebGL canvas through canvas.captureStream() and MediaRecorder, optionally adds microphone audio, and saves the completed video with a native desktop dialog.
Summary: A standalone Tauri v2 example that records a live WebGL canvas through canvas.captureStream() and MediaRecorder, optionally adds microphone audio, and saves the completed video with a native desktop dialog.
Topology: single-window
Platforms: macOS · Windows · Linux
cd v2/14-tauri-v2-canvas-recorder
npm install
npm run dev15-tauri-v2-multipass-compositor
A standalone Tauri v2 + raw WebGL 1 example demonstrating a reusable multipass post-processing architecture with reorderable shader passes, reusable ping-pong work buffers, persistent previous-frame history, native PNG saving, and fullscreen preview.
Summary: A standalone Tauri v2 + raw WebGL 1 example demonstrating a reusable multipass post-processing architecture with reorderable shader passes, reusable ping-pong work buffers, persistent previous-frame history, native PNG saving, and fullscreen preview.
Topology: single-window
Platforms: macOS · Windows · Linux
cd v2/15-tauri-v2-multipass-compositor
npm install
npm run dev16-tauri-v2-image-texture-processor
A standalone Tauri v2 + raw WebGL 1 example for loading still images, processing them in a fragment shader, comparing original and processed results, and exporting full-resolution PNG or JPEG files.
Summary: A standalone Tauri v2 + raw WebGL 1 example for loading still images, processing them in a fragment shader, comparing original and processed results, and exporting full-resolution PNG or JPEG files.
Topology: single-window
Platforms: macOS · Windows · Linux
cd v2/16-tauri-v2-image-texture-processor
npm install
npm run dev17-tauri-v2-glsl-shader-playground
A standalone Tauri v2 + raw WebGL 1 example for editing complete fragment shaders, compiling them live, inspecting a terminal-style diagnostic stream, controlling shared uniforms, loading/saving shader files through native dialogs, and exporting PNG snapshots.
Summary: A standalone Tauri v2 + raw WebGL 1 example for editing complete fragment shaders, compiling them live, inspecting a terminal-style diagnostic stream, controlling shared uniforms, loading/saving shader files through native dialogs, and exporting PNG snapshots.
Topology: single-window
Platforms: macOS · Windows · Linux
cd v2/17-tauri-v2-glsl-shader-playground
npm install
npm run dev18-tauri-v2-texture-mixer
A standalone Tauri v2 + raw WebGL example for compositing two independent image or video sources in one fragment-shader pass.
Summary: A standalone Tauri v2 + raw WebGL example for compositing two independent image or video sources in one fragment-shader pass.
Topology: single-window
Platforms: macOS · Windows · Linux
cd v2/18-tauri-v2-texture-mixer
npm install
npm run dev19-tauri-v2-webcam-compositor
A standalone Tauri v2 + raw WebGL 1 example for combining a live webcam with background replacement, key mattes, graphics overlays, recording, and native export.
Summary: A standalone Tauri v2 + raw WebGL 1 example for combining a live webcam with background replacement, key mattes, graphics overlays, recording, and native export.
Topology: single-window
Platforms: macOS · Windows · Linux
cd v2/19-tauri-v2-webcam-compositor
npm install
npm run dev20-tauri-v2-live-video-switcher
A standalone Tauri v2 + raw WebGL example that turns four reusable media slots into a compact software video switcher. Each source can be an animated pattern, still image, looping video, or shared live camera. Independent Preview and Program buses feed GPU transitions, a lower-third/logo overlay, MediaRecorder capture, native saving, a…
Summary: A standalone Tauri v2 + raw WebGL example that turns four reusable media slots into a compact software video switcher. Each source can be an animated pattern, still image, looping video, or shared live camera. Independent Preview and Program buses feed GPU transitions, a lower-third/logo overlay, MediaRecorder capture, native saving, a…
Topology: single-window
Platforms: macOS · Windows · Linux
cd v2/20-tauri-v2-live-video-switcher
npm install
npm run dev21-tauri-v2-projection-mapper
A standalone two-window projection-mapping foundation built with Tauri v2 and raw WebGL 1.
Summary: A standalone two-window projection-mapping foundation built with Tauri v2 and raw WebGL 1.
Topology: two-window
Platforms: macOS · Windows · Linux
cd v2/21-tauri-v2-projection-mapper
npm install
npm run dev22-tauri-v2-image-sequence-player
A two-window Tauri v2 example for playing numbered still-image sequences as time-based media. The controls WebView handles native folder/file selection and transport. The output WebView owns the decode cache, playback clock, WebGL renderer, monitor placement, and PNG capture.
Summary: A two-window Tauri v2 example for playing numbered still-image sequences as time-based media. The controls WebView handles native folder/file selection and transport. The output WebView owns the decode cache, playback clock, WebGL renderer, monitor placement, and PNG capture.
Topology: two-window
Platforms: macOS · Windows · Linux
cd v2/22-tauri-v2-image-sequence-player
npm install
npm run dev23-tauri-v2-audio-file-fft-visualizer
A standalone Tauri v2 example that analyzes a local audio file with the Web Audio API, uploads the full FFT and waveform to WebGL textures, renders audio-reactive GLSL visuals, and records the result with the source audio included.
Summary: A standalone Tauri v2 example that analyzes a local audio file with the Web Audio API, uploads the full FFT and waveform to WebGL textures, renders audio-reactive GLSL visuals, and records the result with the source audio included.
Topology: single-window
Platforms: macOS · Windows · Linux
cd v2/23-tauri-v2-audio-file-fft-visualizer
npm install
npm run dev24-tauri-v2-keyframe-automation
A standalone Tauri v2/WebGL example for animating visual parameters on an editable timeline, recording live changes, and saving complete automation projects.
Summary: A standalone Tauri v2/WebGL example for animating visual parameters on an editable timeline, recording live changes, and saving complete automation projects.
Topology: single-window
Platforms: macOS · Windows · Linux
cd v2/24-tauri-v2-keyframe-automation
npm install
npm run dev25-tauri-v2-multi-display-output-manager
The final Tauri v2 Essential demonstrates how one controls WebView can manage three independent native WebGL output windows at the same time.
Summary: The final Tauri v2 Essential demonstrates how one controls WebView can manage three independent native WebGL output windows at the same time.
Topology: single-window
Platforms: macOS · Windows · Linux
cd v2/25-tauri-v2-multi-display-output-manager
npm install
npm run dev00-wgpu-surface-probe
The smallest native-rendering example in Junkpile.
Summary: The smallest native-rendering example in Junkpile.
Topology: native-window
Platforms: macOS · Windows · Linux
cd wgpu/00-wgpu-surface-probe
npm install
npm run dev01-wgpu-resize-fullscreen
Adds the complete surface lifecycle to the raw Tauri window.
Summary: Adds the complete surface lifecycle to the raw Tauri window.
Topology: native-window
Platforms: macOS · Windows · Linux
cd wgpu/01-wgpu-resize-fullscreen
npm install
npm run dev02-wgpu-wgsl-shader
The first complete procedural native visual.
Summary: The first complete procedural native visual.
Topology: native-window
Platforms: macOS · Windows · Linux
cd wgpu/02-wgpu-wgsl-shader
npm install
npm run dev03-wgpu-tauri-controls
The reusable native-wgpu application pattern for Junkpile.
Summary: The reusable native-wgpu application pattern for Junkpile.
Topology: hybrid-controls-native-renderer
Platforms: macOS · Windows · Linux
cd wgpu/03-wgpu-tauri-controls
npm install
npm run dev04-wgpu-image-texture
A native Tauri 2 + wgpu example showing the complete path from encoded image bytes to a sampled GPU texture.
Summary: A native Tauri 2 + wgpu example showing the complete path from encoded image bytes to a sampled GPU texture.
Topology: native-window
Platforms: macOS · Windows · Linux
cd wgpu/04-wgpu-image-texture
npm install
npm run dev05-wgpu-ping-pong-feedback
Native HDR feedback using two Rgba16Float render textures. One texture is sampled while the other is written, then their roles swap for the next frame.
Summary: Native HDR feedback using two Rgba16Float render textures. One texture is sampled while the other is written, then their roles swap for the next frame.
Topology: native-window
Platforms: macOS · Windows · Linux
cd wgpu/05-wgpu-ping-pong-feedback
npm install
npm run dev06-wgpu-multipass-render-graph
A readable four-pass native GPU pipeline:
Summary: A readable four-pass native GPU pipeline:
Topology: native-window
Platforms: macOS · Windows · Linux
cd wgpu/06-wgpu-multipass-render-graph
npm install
npm run dev07-wgpu-high-resolution-lab
This example decouples internal render definition from the size of the visible window.
Summary: This example decouples internal render definition from the size of the visible window.
Topology: native-window
Platforms: macOS · Windows · Linux
cd wgpu/07-wgpu-high-resolution-lab
npm install
npm run dev08-wgpu-backend-lab
A standalone Tauri 2 + Rust/wgpu example for inspecting which native GPU backends and adapters are available, then running the same WGSL workload through the selected backend.
Summary: A standalone Tauri 2 + Rust/wgpu example for inspecting which native GPU backends and adapters are available, then running the same WGSL workload through the selected backend.
Topology: native-window
Platforms: macOS · Windows · Linux
cd wgpu/08-wgpu-backend-lab
npm install
npm run dev09-wgpu-compute-particles-additive-blend
A standalone Tauri 2 + Rust/wgpu example for inspecting which native GPU backends and adapters are available, then running the same WGSL workload through the selected backend.
Summary: A standalone Tauri 2 + Rust/wgpu example for inspecting which native GPU backends and adapters are available, then running the same WGSL workload through the selected backend.
Topology: native-window
Platforms: macOS · Windows · Linux
cd wgpu/09-wgpu-compute-particles-additive-blend
npm install
npm run dev10-wgpu-3d-particle-volume
A standalone Tauri 2 + Rust/wgpu example that extends the compute-particle system into a true XYZ simulation and perspective renderer.
Summary: A standalone Tauri 2 + Rust/wgpu example that extends the compute-particle system into a true XYZ simulation and perspective renderer.
Topology: native-window
Platforms: macOS · Windows · Linux
cd wgpu/10-wgpu-3d-particle-volume
npm install
npm run dev11-wgpu-volumetric-raymarcher
A standalone Tauri 2 + Rust + wgpu 29 example that renders procedural three-dimensional signed-distance fields directly to a native Metal, Vulkan, or DX12 surface.
Summary: A standalone Tauri 2 + Rust + wgpu 29 example that renders procedural three-dimensional signed-distance fields directly to a native Metal, Vulkan, or DX12 surface.
Topology: native-window
Platforms: macOS · Windows · Linux
cd wgpu/11-wgpu-volumetric-raymarcher
npm install
npm run dev12-wgpu-compute-fluid-feedback
A standalone Tauri 2 + Rust + wgpu 29 example that runs a two-dimensional incompressible-fluid approximation entirely on the GPU.
Summary: A standalone Tauri 2 + Rust + wgpu 29 example that runs a two-dimensional incompressible-fluid approximation entirely on the GPU.
Topology: native-window
Platforms: macOS · Windows · Linux
cd wgpu/12-wgpu-compute-fluid-feedback
npm install
npm run dev13-wgpu-voxel-feedback-volume
A standalone Tauri 2 + Rust/wgpu example that evolves a persistent three-dimensional RGBA16F field with a WGSL compute shader, then renders it with a volume raymarcher.
Summary: A standalone Tauri 2 + Rust/wgpu example that evolves a persistent three-dimensional RGBA16F field with a WGSL compute shader, then renders it with a volume raymarcher.
Topology: native-window
Platforms: macOS · Windows · Linux
cd wgpu/13-wgpu-voxel-feedback-volume
npm install
npm run dev14-wgpu-native-webcam-texture-avfoundation-macos
This revision replaces the slow macOS Nokhwa/YUYV path with a direct AVFoundation capture backend.
Summary: This revision replaces the slow macOS Nokhwa/YUYV path with a direct AVFoundation capture backend.
Topology: hybrid-controls-native-renderer
Platforms: macOS
cd wgpu/14-wgpu-native-webcam-texture-avfoundation-macos
npm install
npm run dev15-wgpu-native-video-decoder-effect-ui
A standalone Tauri 2 + Rust + wgpu example that decodes local video files through FFmpeg, publishes only the newest decoded BGRA frame, and uploads that frame to a native Metal / Vulkan / DX12 texture.
Summary: A standalone Tauri 2 + Rust + wgpu example that decodes local video files through FFmpeg, publishes only the newest decoded BGRA frame, and uploads that frame to a native Metal / Vulkan / DX12 texture.
Topology: hybrid-controls-native-renderer
Platforms: macOS · Windows · Linux
cd wgpu/15-wgpu-native-video-decoder-effect-ui
npm install
npm run dev16-wgpu-audio-reactive-spectrum
A Tauri 2 + Rust + wgpu example that treats live audio as a structured native input source rather than a single volume value.
Summary: A Tauri 2 + Rust + wgpu example that treats live audio as a structured native input source rather than a single volume value.
Topology: hybrid-controls-native-renderer
Platforms: macOS · Windows · Linux
cd wgpu/16-wgpu-audio-reactive-spectrum
npm install
npm run dev17-wgpu-midi-parameter-registry
A standalone Tauri 2 + Rust/wgpu example showing how native MIDI messages become reusable renderer parameters rather than hard-coded controller assignments.
Summary: A standalone Tauri 2 + Rust/wgpu example showing how native MIDI messages become reusable renderer parameters rather than hard-coded controller assignments.
Topology: hybrid-controls-native-renderer
Platforms: macOS · Windows · Linux
cd wgpu/17-wgpu-midi-parameter-registry
npm install
npm run dev18-wgpu-osc-network-control
A standalone Tauri 2 + Rust + wgpu 29 example that receives Open Sound Control messages over UDP and routes them through a reusable parameter registry before rendering on a native Metal, Vulkan, or DX12 surface.
Summary: A standalone Tauri 2 + Rust + wgpu 29 example that receives Open Sound Control messages over UDP and routes them through a reusable parameter registry before rendering on a native Metal, Vulkan, or DX12 surface.
Topology: hybrid-controls-native-renderer
Platforms: macOS · Windows · Linux
cd wgpu/18-wgpu-osc-network-control
npm install
npm run dev19-wgpu-gesture-field
This revision contains the WGSL reserved-keyword correction. The controls window visibly shows BUILD 19.2 · WGSL KEYWORD FIX. If that marker is absent, an older project folder is running.
Summary: This revision contains the WGSL reserved-keyword correction. The controls window visibly shows BUILD 19.2 · WGSL KEYWORD FIX. If that marker is absent, an older project folder is running.
Topology: hybrid-controls-native-renderer
Platforms: macOS · Windows · Linux
cd wgpu/19-wgpu-gesture-field
npm install
npm run dev20-wgpu-multi-input-compositor
A standalone Tauri 2 + Rust/wgpu convergence example that combines the input systems developed in examples 14–19 into one native render graph.
Summary: A standalone Tauri 2 + Rust/wgpu convergence example that combines the input systems developed in examples 14–19 into one native render graph.
Topology: hybrid-controls-native-renderer
Platforms: macOS · Windows · Linux
cd wgpu/20-wgpu-multi-input-compositor
npm install
npm run dev21-wgpu-gltf-scene-loader
A standalone Tauri 2 + wgpu 29 example for importing glTF 2.0 scenes into a native Metal, Vulkan, or DirectX 12 render surface.
Summary: A standalone Tauri 2 + wgpu 29 example for importing glTF 2.0 scenes into a native Metal, Vulkan, or DirectX 12 render surface.
Topology: hybrid-controls-native-renderer
Platforms: macOS · Windows · Linux
cd wgpu/21-wgpu-gltf-scene-loader
npm install
npm run dev22-wgpu-skeletal-pose-lab
A standalone Tauri 2 + wgpu 29 example for loading, animating, inspecting, and manually posing skinned glTF/GLB characters on a native GPU surface.
Summary: A standalone Tauri 2 + wgpu 29 example for loading, animating, inspecting, and manually posing skinned glTF/GLB characters on a native GPU surface.
Topology: hybrid-controls-native-renderer
Platforms: macOS · Windows · Linux
cd wgpu/22-wgpu-skeletal-pose-lab
npm install
npm run dev23-wgpu-morph-target-lab
A two-window Tauri 2 + Rust + wgpu example demonstrating GPU morph-target animation with a fixed mesh topology.
Summary: A two-window Tauri 2 + Rust + wgpu example demonstrating GPU morph-target animation with a fixed mesh topology.
Topology: hybrid-controls-native-renderer
Platforms: macOS · Windows · Linux
cd wgpu/23-wgpu-morph-target-lab
npm install
npm run dev24-wgpu-mesh-feedback-deformer
A standalone Tauri 2 + wgpu example that treats mesh geometry as a persistent GPU feedback system.
Summary: A standalone Tauri 2 + wgpu example that treats mesh geometry as a persistent GPU feedback system.
Topology: hybrid-controls-native-renderer
Platforms: macOS · Windows · Linux
cd wgpu/24-wgpu-mesh-feedback-deformer
npm install
npm run dev25-wgpu-ultra-resolution-export
A standalone Tauri 2 + wgpu example for rendering resolution-independent GPU artwork and exporting it as tiled 4K, 6K, 8K, or square PNG files.
Summary: A standalone Tauri 2 + wgpu example for rendering resolution-independent GPU artwork and exporting it as tiled 4K, 6K, 8K, or square PNG files.
Topology: native-window
Platforms: macOS · Windows · Linux
cd wgpu/25-wgpu-ultra-resolution-export
npm install
npm run dev26-wgpu-io-config-foundation
A standalone Tauri 2 + native wgpu example that establishes the configuration layer for future Junkpile recording, streaming, NDI, Syphon, Spout, receiver, and routing examples.
Summary: A standalone Tauri 2 + native wgpu example that establishes the configuration layer for future Junkpile recording, streaming, NDI, Syphon, Spout, receiver, and routing examples.
Topology: hybrid-controls-native-renderer
Platforms: macOS · Windows · Linux
cd wgpu/26-wgpu-io-config-foundation
npm install
npm run dev27-wgpu-frame-output-contract
This native wgpu + Tauri 2 example establishes the shared frame and output-sink contract for the new Junkpile I/O series.
Summary: This native wgpu + Tauri 2 example establishes the shared frame and output-sink contract for the new Junkpile I/O series.
Topology: hybrid-controls-native-renderer
Platforms: macOS · Windows · Linux
cd wgpu/27-wgpu-frame-output-contract
npm install
npm run dev28-wgpu-ffmpeg-record
This native wgpu + Tauri 2 example replaces Example 27's simulated CPU worker with a real GPU-to-CPU readback pipeline and FFmpeg file writer.
Summary: This native wgpu + Tauri 2 example replaces Example 27's simulated CPU worker with a real GPU-to-CPU readback pipeline and FFmpeg file writer.
Topology: hybrid-controls-native-renderer
Platforms: macOS · Windows · Linux
cd wgpu/28-wgpu-ffmpeg-record
npm install
npm run dev30-wgpu-high-resolution-record
A native wgpu + Tauri 2 teaching example for recording procedural GPU output at a resolution independent from the visible preview window.
Summary: A native wgpu + Tauri 2 teaching example for recording procedural GPU output at a resolution independent from the visible preview window.
Topology: hybrid-controls-native-renderer
Platforms: macOS · Windows · Linux
cd wgpu/30-wgpu-high-resolution-record
npm install
npm run dev31-wgpu-io-profile-router
A native wgpu + Tauri 2 teaching example for describing render and file-output routes as validated, hot-reloadable JSON profiles.
Summary: A native wgpu + Tauri 2 teaching example for describing render and file-output routes as validated, hot-reloadable JSON profiles.
Topology: hybrid-controls-native-renderer
Platforms: macOS · Windows · Linux
cd wgpu/31-wgpu-io-profile-router
npm install
npm run dev32-wgpu-ndi-sender
A focused native-wgpu example that ports ShadeCore's NDI output concept into the Junkpile renderer family.
Summary: A focused native-wgpu example that ports ShadeCore's NDI output concept into the Junkpile renderer family.
Topology: hybrid-controls-native-renderer
Platforms: macOS · Windows · Linux
cd wgpu/32-wgpu-ndi-sender
npm install
npm run dev33-wgpu-preview-output-modes
A focused native-wgpu example that ports ShadeCore's preview/presentation concepts into the Junkpile I/O track.
Summary: A focused native-wgpu example that ports ShadeCore's preview/presentation concepts into the Junkpile I/O track.
Topology: hybrid-controls-native-renderer
Platforms: macOS · Windows · Linux
cd wgpu/33-wgpu-preview-output-modes
npm install
npm run dev34-wgpu-shader-parameter-hotreload
A native Tauri 2 + wgpu example that expands ShadeCore's live shader and parameter configuration concepts into a demanding WGSL laboratory.
Summary: A native Tauri 2 + wgpu example that expands ShadeCore's live shader and parameter configuration concepts into a demanding WGSL laboratory.
Topology: hybrid-controls-native-renderer
Platforms: macOS · Windows · Linux
cd wgpu/34-wgpu-shader-parameter-hotreload
npm install
npm run dev35-wgpu-assets-state-logging
A native Tauri 2 + wgpu example that isolates the runtime-infrastructure concepts used by ShadeCore:
Summary: A native Tauri 2 + wgpu example that isolates the runtime-infrastructure concepts used by ShadeCore:
Topology: hybrid-controls-native-renderer
Platforms: macOS · Windows · Linux
cd wgpu/35-wgpu-assets-state-logging
npm install
npm run dev36-wgpu-runtime-output-router
A native Tauri 2 + wgpu reference application that routes one authoritative GPU texture to independent preview, NDI, and FFmpeg recording sinks.
Summary: A native Tauri 2 + wgpu reference application that routes one authoritative GPU texture to independent preview, NDI, and FFmpeg recording sinks.
Topology: hybrid-controls-native-renderer
Platforms: macOS · Windows · Linux
cd wgpu/36-wgpu-runtime-output-router
npm install
npm run dev37-wgpu-syphon-sender
A focused macOS-native wgpu example that integrates ShadeCore's Syphon output concept into the Junkpile renderer family.
Summary: A focused macOS-native wgpu example that integrates ShadeCore's Syphon output concept into the Junkpile renderer family.
Topology: hybrid-controls-native-renderer
Platforms: macOS
cd wgpu/37-wgpu-syphon-sender
npm install
npm run dev38-wgpu-spout-sender
Windows-only Spout2 output for the native Junkpile wgpu track.
Summary: Windows-only Spout2 output for the native Junkpile wgpu track.
Topology: hybrid-controls-native-renderer
Platforms: Windows
cd wgpu/38-wgpu-spout-sender
npm install
npm run dev39-wgpu-cross-platform-output-router
A native Tauri 2 + wgpu reference application that renders one authoritative GPU texture and routes it at runtime to multiple independent output sinks:
Summary: A native Tauri 2 + wgpu reference application that renders one authoritative GPU texture and routes it at runtime to multiple independent output sinks:
Topology: hybrid-controls-native-renderer
Platforms: macOS · Windows · Linux
cd wgpu/39-wgpu-cross-platform-output-router
npm install
npm run dev40-wgpu-network-output
A native Tauri 2 + wgpu example that publishes one authoritative GPU frame through UDP/MPEG-TS, RTSP/TCP, or RTMP/FLV without blocking the renderer.
Summary: A native Tauri 2 + wgpu example that publishes one authoritative GPU frame through UDP/MPEG-TS, RTSP/TCP, or RTMP/FLV without blocking the renderer.
Topology: hybrid-controls-native-renderer
Platforms: macOS · Windows · Linux
cd wgpu/40-wgpu-network-output
npm install
npm run dev41-wgpu-appliance-runtime
A native Tauri 2 + wgpu example for running Junkpile as an unattended media appliance.
Summary: A native Tauri 2 + wgpu example for running Junkpile as an unattended media appliance.
Topology: hybrid-controls-native-renderer
Platforms: macOS · Windows · Linux
cd wgpu/41-wgpu-appliance-runtime
npm install
npm run dev42-wgpu-audio-reactive-fft
A native Rust/wgpu counterpart to the WebView audio-reactive FFT workflow: microphone capture, FFT and waveform analysis, beat detection, GPU analysis textures, and live audio-reactive graphics.
Summary: A native Rust/wgpu counterpart to the WebView audio-reactive FFT workflow: microphone capture, FFT and waveform analysis, beat detection, GPU analysis textures, and live audio-reactive graphics.
Topology: hybrid-controls-native-renderer
Platforms: macOS · Windows · Linux
cd wgpu/42-wgpu-audio-reactive-fft
npm install
npm run dev43-wgpu-av-recorder
Focused native Tauri 2 + wgpu recorder with selectable audio source.
Summary: Focused native Tauri 2 + wgpu recorder with selectable audio source.
Topology: hybrid-controls-native-renderer
Platforms: macOS · Windows · Linux
cd wgpu/43-wgpu-av-recorder
npm install
npm run dev44-wgpu-wgsl-shader-playground
A native Tauri 2 + wgpu counterpart to Junkpile's WebView shader playground workflow.
Summary: A native Tauri 2 + wgpu counterpart to Junkpile's WebView shader playground workflow.
Topology: native-window
Platforms: macOS · Windows · Linux
cd wgpu/44-wgpu-wgsl-shader-playground
npm install
npm run devA working example is most useful when you can tell whether your change caused the failure. Keep the original behavior easy to reproduce, then change one boundary at a time.
See DEVELOPMENT.md and ADDING_AN_EXAMPLE.md.
Do not debug the entire application at once. First decide whether the problem belongs to the WebView, the native GPU path, or an external I/O worker, then inspect the tools and state owned by that layer.
Console, shader compile/link, media permission, browser texture upload, WebSocket state.
Adapter/backend, surface state, bind groups, buffer alignment, texture formats, resource usage.
Readback slots, CPU pools, bounded queues, FFmpeg stderr, SDK/runtime dependencies.
See the full troubleshooting guide.