Hooviestar

Native GPU scene compositing for a clean Discord screen-share window on Windows and Linux.

Hooviestar keeps scene setup, source controls, audio mixing, and preview tooling in one visible studio window. In Discord, select the virtual Hooviestar – Program app: it stays mapped for capture but outside the physical desktop, so controls and setup dialogs never become part of the shared output.

Status: Hooviestar is at version 0.1.14 and under active development. Build it from source and expect the project format and platform integration to evolve.

Highlights

• Native render paths: D3D11 on Windows and Vulkan 1.2 on Linux.
• Window and display capture through Windows Graphics Capture or the Linux desktop portal and PipeWire.
• Window, display, text, image, local media, and application-audio sources.
• Scene ordering, visibility, locking, renaming, and global scene hotkeys.
• Per-source volume, mute controls, live meters, and media playback controls.
• One visible Studio plus capture-only Program and native Preview surfaces.
• Single-instance startup that restores and focuses the existing Studio.
• Persisted Studio size, position, and maximized state with monitor-safe restore.
• Native taskbar update progress and a Windows error overlay for failed updates or GPU recovery.
• Atomic, debounced project persistence with corrupt-file recovery.
• Shared JSON command, event, and project contracts across TypeScript and Rust.

Screenshots

The screenshots show the Linux Tauri application. On Hyprland, Hooviestar uses XWayland for stable ownership of its Vulkan surfaces and keeps them in a hidden special workspace; classic X11 places them offscreen. Windows embeds the D3D11 preview in the Studio surface.

Platform paths

Area	Windows	Linux
Composition	D3D11	Vulkan 1.2
Window capture	Windows Graphics Capture	xdg-desktop-portal and PipeWire
Display capture	DXGI output capture	xdg-desktop-portal and PipeWire
Application audio	WASAPI process loopback	PipeWire nodes
Images and media	WIC and Media Foundation	Image decoders and GStreamer
Preview	Embedded native child surface	Hidden native Vulkan surface
Bundle	NSIS installer	AppImage and Debian package

Local media with video stays on the native GPU path. On Linux, GStreamer must negotiate DMA-BUF/NV12 surfaces; if a video decoder is unavailable or incompatible, Hooviestar reports Unsupported instead of silently playing only the audio track. No CPU/system-memory video fallback is promised.

Requirements

• Node.js 24.x. The repository declares >=24 <25.
• Rust with Cargo, rustfmt, and Clippy. The workspace MSRV is Rust 1.96.
• The Tauri 2 system prerequisites for the host platform.

Linux

Linux additionally needs:

• A Vulkan 1.2-capable GPU and matching Vulkan driver.
• PipeWire and a desktop-specific xdg-desktop-portal implementation.
• GStreamer with the base, good, and bad plugin sets.
• WebKitGTK 4.1 and the native development headers used by Tauri.
• pkg-config and the PipeWire development metadata used by AppImage staging.

Ubuntu 24.04 and related distributions can install the build and runtime dependencies with:

sudo apt update
sudo apt install \
  build-essential curl wget file pkg-config libssl-dev libxdo-dev \
  libwebkit2gtk-4.1-dev libayatana-appindicator3-dev librsvg2-dev patchelf \
  libpipewire-0.3-dev libspa-0.2-modules pipewire-bin libjack-jackd2-0 libvulkan-dev libclang-dev \
  libgstreamer1.0-dev libgstreamer-plugins-base1.0-dev \
  gstreamer1.0-plugins-base gstreamer1.0-plugins-good gstreamer1.0-plugins-bad

On Arch Linux, install the equivalent packages:

sudo pacman -S --needed \
  base-devel webkit2gtk-4.1 librsvg patchelf pkgconf clang \
  pipewire pipewire-jack libpipewire vulkan-headers vulkan-icd-loader \
  gstreamer gst-plugins-base gst-plugins-good gst-plugins-bad

Install the Vulkan driver and portal implementation appropriate for the desktop separately, such as vulkan-radeon plus xdg-desktop-portal-hyprland.

Windows

Install Microsoft C++ Build Tools with the Desktop development with C++ workload and the Microsoft Edge WebView2 Runtime. Use the x86_64-pc-windows-msvc Rust target for the supported Windows build.

Run locally

git clone https://github.com/openhoo/hooviestar.git
cd hooviestar
npm ci
npm run tauri dev

The app creates three surfaces, but only the Studio is visible on the physical desktop:

1. Hooviestar is the Studio control surface.
2. Hooviestar – Program is the capture-only output to select under Discord's Applications tab.
3. Hooviestar – Preview is an internal native Linux render target. Windows renders the preview inside Studio.

Do not minimize or reveal the Program surface. Hooviestar keeps it mapped and rendered automatically: in a hidden Hyprland special workspace on Wayland, outside the virtual desktop on X11 and Windows. This is necessary because a genuinely hidden/unmapped window is not available in Discord's application picker.

Use Studio beenden or close the Studio window to exit the whole application. Hooviestar flushes the project and shuts down the capture/audio engine and both internal output surfaces; closing Studio does not leave an invisible background instance.

On first start, Hooviestar creates three scenes:

• Spiel (Ctrl+Alt+1) receives game/window capture.
• Video (Ctrl+Alt+2) receives local video.
• Beides (Ctrl+Alt+3) combines game capture with a picture-in-picture video.

The default hotkeys also identify these roles when Hooviestar places newly added sources automatically. Scene names may change; keep the three default hotkeys assigned if automatic placement is required.

Editing scenes and sources

Click a source in the preview or source dock to select it. Hover highlights the source under the pointer; the selected item has a high-contrast outline and eight resize handles with 24-pixel interaction targets. Drag its body to move it or a handle to resize it. Rotated resizing keeps the opposite handle fixed. Locked items remain selectable but show no resize handles, cannot be moved or resized, and have disabled inspector fields.

The preview fits the available space without changing the output aspect ratio. The source name, lock state, position, and dimensions remain visible below the canvas, including during a drag. Selection does not change the canvas geometry, and editing guides stay opaque even for transparent sources. A click without dragging does not change the transform; Escape, loss of focus, or pointer cancellation discards an unfinished drag.

Control	Action
Arrow keys in the preview	Move the selected item by one output pixel
Shift + arrow keys	Move by ten output pixels
Alt + arrow keys	Change width/height by one output pixel; left/up shrink
Alt + Shift + arrow keys	Change width/height by ten output pixels
Escape during a drag	Cancel without committing the drag
Delete or Backspace on the active scene/selected source row or its delete button	Open a removal confirmation
Escape, Cancel, or an outside click in the confirmation	Cancel and restore focus

These editing shortcuts do not intercept typing in text/numeric fields or controls inside a dialog. Inspector transform fields commit on blur; failed or stale updates are shown rather than silently overwriting a newer edit.

Scene deletion activates a remaining scene; the final scene cannot be removed. Source removal is global: the confirmation lists affected scenes, and confirming also removes that source's scene items. Locking an item's transform does not protect the underlying source from an explicitly confirmed global removal.

On Windows, a separate native preview overlay supplies visible selection guides and mouse input above the GPU child window. It is hidden with the preview when a modal is open and never becomes part of the Program output. Release builds use the Windows GUI subsystem; debug builds retain their console. Native renderer startup failures show a Windows diagnostic instead of silently offering a nonfunctional output.

Build installers

Install frontend dependencies first with npm ci, then build on the target operating system.

Linux:

NO_STRIP=1 GSTREAMER_INCLUDE_BAD_PLUGINS=1 \
  npm run tauri-appimage -- --bundles appimage,deb \
  --target x86_64-unknown-linux-gnu \
  --config src-tauri/tauri.local-build.conf.json

Windows:

npm run tauri build -- --bundles nsis --target x86_64-pc-windows-msvc --no-sign --config src-tauri/tauri.local-build.conf.json

The local override disables updater artifacts, so ordinary developers do not need the protected release signing key. NO_STRIP=1 avoids the older linuxdeploy strip tool failing on modern DT_RELR libraries; GSTREAMER_INCLUDE_BAD_PLUGINS=1 includes the runtime plugins Hooviestar uses. Windows also uses --no-sign; only the tag workflow produces publisher-signed release installers. Bundles are written below target/<target>/release/bundle/.

On Linux, tauri-appimage runs the normal Tauri build, then preserves linuxdeploy's generated AppRun.shell and AppRun.wrapped, installs a statically linked native AppRun bootstrap, and repackages the AppImage before any updater signature is recreated. The bootstrap clears only inherited LD_LIBRARY_PATH before the generated shell interpreter starts, sets APPDIR to the actual AppDir, preserves APPIMAGE and arguments, and leaves other environment variables unchanged. It requires a C compiler with static libc development files; set CC to an architecture-matching compiler when cross-building.

The Tauri beforeBuildCommand still runs node scripts/release/stage-pipewire-appimage.mjs. It uses pkg-config to resolve the matching PipeWire and SPA directories, fails if required runtime directories or spa-0.2/support/libspa-support.so, pipewire-0.3/libpipewire-module-protocol-native.so, or share/pipewire/client.conf are missing, and stages every libpipewire-0.3.so* and libjack.so* file (including libjack.so.0), the SPA plugins, PipeWire modules, and config under src-tauri/resources/pipewire.

At startup, Linux enables those staged paths only when APPDIR points to an AppImage tree containing usr/lib/spa-0.2, usr/lib/pipewire-0.3, and usr/share/pipewire/client.conf; it then sets SPA_PLUGIN_DIR, PIPEWIRE_MODULE_DIR, and PIPEWIRE_CONFIG_DIR. Development and other non-AppImage runs leave the host PipeWire configuration unchanged. The release gate extracts the AppImage and runs scripts/release/verify-appimage-pipewire.mjs, which verifies the static bootstrap has no ELF interpreter, checks the preserved generated AppRun chain, launches it with a poisoned inherited library path, and exercises a PipeWire client-context plus bundled GStreamer-plugin loading probe.

Test and qualify

npm test
npm run build
npm run release:test
cargo fmt --all --check
cargo clippy --workspace --all-targets -- -D warnings
cargo test --workspace

CI runs the frontend checks, Rust tests on Windows and Linux, the Rust 1.96 MSRV check, and release-configuration validation. Installer builds run only for version tags.

Windows also has an interactive, measured Discord qualification for real scene switching, offscreen Program capture, browser <video> motion, application sound, per-source mute/volume, mixing, limiter behavior, and receiver-side Discord transport. See Windows and Discord qualification. Run its native layer with:

pwsh -File .\scripts\windows-discord\Start-Publisher.ps1 -NativeOnly

The reusable workflow is versioned as the Windows/Discord qualification skill. Its deterministic negative and harness-contract tests run with npm run test:windows-qualification. Full qualification requires fresh same-run publisher and receiver JSON reports; ordinary hosted CI cannot replace the interactive Discord/GPU/audio run.

Version tags produce a Windows NSIS installer, Linux AppImage, and Debian package. The release stays a draft until Windows Authenticode, Tauri updater signatures, an SPDX 2.3 SBOM, SHA-256 checksums, Sigstore signing, GitHub provenance/SBOM attestations, and the cross-platform latest.json manifest pass verification. Packaged builds check for signed updates on startup and download a newer signed version to a ready state. Installation is not automatic: the user must explicitly confirm Installieren und neu starten. Before installation, Hooviestar applies pending source and mixer changes and saves the project so saved project data survives the restart. Apply changes in open dialogs before confirming the restart.

See Releasing Hooviestar for signing-secret setup, version preparation, publication, updater behavior, and independent verification. The Windows integration review records current bundle metadata and prioritized native Tauri opportunities.

Project data

Hooviestar saves the current project automatically:

• Linux: ${XDG_CONFIG_HOME:-$HOME/.config}/hooviestar/project.json
• Windows: %APPDATA%\Hooviestar\project.json

Writes are atomic and debounced. If the project file is invalid or corrupt, Hooviestar moves it aside and starts with a fresh project.

Repository layout

src/                         React studio UI and validated IPC contracts
src-tauri/                   Tauri shell, native windows, hotkeys, and IPC
crates/hooviestar-engine/    Scene state, persistence, capture, audio, and rendering
contracts/                   Shared JSON contract fixtures
.github/workflows/ci.yml     Frontend, Rust, MSRV, and bundle qualification

Current boundaries

• Windows and Linux are implemented; macOS is not currently supported.
• Project output accepts the 1280×720 at 30 fps and 1920×1080 at 60 fps presets.
• The Studio interface is currently German.
• Linux screen and window access is session-scoped and must be approved through the desktop portal.
• Invisible Wayland output currently requires Hyprland. X11 and Windows use an offscreen mapped window.

The Rust workspace declares the project under the MIT license.