- Top Pick: Focusrite Scarlett 2i2 (4th Generation)
- Runner-up: Samson Q2U
- Also consider: Elgato Wave:3
PipeWire replaced the old one-device-at-a-time audio model with a single media graph, and that graph is powerful but invisible. Your game, your voice chat client, your microphone and OBS all appear inside it as separate streams, yet most desktop tools only let you pick one output device per application. Helvum is the small GTK application that makes the graph visible: it draws every node as a box with input and output ports, and lets you connect them by dragging links, the way a hardware patchbay works in a studio.
This guide explains what Helvum does on a gaming PC, which routing jobs it solves for players and streamers, and where its limits sit. It also covers the comparison with qpwgraph, and the behaviour that surprises new users: links drawn in a patchbay are session state, not saved configuration.
As an Amazon Associate, we earn from qualifying purchases.
Quick answer
Helvum is a GTK patchbay that draws your PipeWire audio graph as boxes and cables. Every game, chat client, microphone and headset appears as a node with input and output ports, and you connect them by dragging links. It changes where audio goes, never how it sounds, and it pairs with effects tools rather than replacing them.
What a patchbay actually does: nodes, ports and links
PipeWire organises audio as a graph of nodes. A node is anything that produces or consumes a stream: a running game, a browser tab, a USB microphone, a headset, an audio interface, or a virtual device such as a null sink created for recording. Each node exposes ports, the channels it can send or receive, and a link is a connection between an output port on one node and an input port on another. Audio flows only where links exist.
The session manager, WirePlumber on most current distributions, creates sensible default links automatically: a new game is linked to your default headset, a chat client to your default microphone. Helvum, developed in the open as part of the PipeWire project area on freedesktop.org, shows those links as drawn cables and lets you change them directly. Drag from an output port to an input port to create a link; drag an existing link apart to remove it. Nothing is processed or mixed along the way: Helvum edits the wiring diagram, and PipeWire follows it immediately.
That distinction defines what Helvum is not. It has no equaliser, no noise suppression, no processing of its own. If a stream sounds wrong, a patchbay is the wrong tool. If a stream is going to the wrong place, or missing from the application that should hear it, a patchbay is exactly the right one.
The routing jobs gamers actually use it for
The classic case is splitting a stream setup. A player wants the game’s audio captured by OBS on its own track, voice chat kept off that track, and the microphone recorded separately again. The usual recipe is to create virtual sinks, one per source group, then wire each application to its sink. In Helvum the whole arrangement is one picture: the game node linked to the game sink, the chat node linked to the chat sink, each sink linked onward to OBS, and the headset receiving only the mix the player wants to hear. When something is wrong, the wrong cable is visible.
The second case is microphone chains. Tools such as EasyEffects and NoiseTorch insert themselves into the graph as filter nodes: the microphone feeds the processor, and the processed output is what chat applications should receive. Sometimes the session manager links a chat client straight to the raw microphone instead, bypassing the chain, and the player never notices until someone mentions the keyboard noise. In Helvum that mistake is a single wrong cable, fixed by dragging the chat client’s input from the microphone node to the processor’s output node. The processors change the sound; the patchbay decides which version each application gets.
A third, quieter use is diagnosis. When audio vanishes, the graph answers questions that otherwise take guesswork: does the game node exist at all, is it linked anywhere, is it linked to a device that is switched off. It also confirms a capture source is fed before a recording starts, rather than revealing a silent track afterwards.
Helvum vs qpwgraph
The realistic alternative is qpwgraph, a Qt graph manager for PipeWire by Rui Nuno Capela, and the two tools draw the same graph and differ mainly in what happens afterwards. Helvum is deliberately minimal: a GTK window, the graph, drag to connect, close it when you are done. It fits GNOME-style desktops visually and asks nothing of you between sessions.
qpwgraph adds a patchbay feature on top of the live graph: connections can be saved to a file, restored from it, and actively maintained, including an exclusive mode that disconnects anything outside it. That is a real functional difference, and the standard answer when a layout must survive reboots. The trade-off is a busier interface and a tool you run as a session utility rather than an occasional editor. Players who rewire rarely tend to prefer Helvum; streamers with a fixed multi-sink layout tend to prefer qpwgraph, or session-manager rules instead.
The honest limit: links are session state
Helvum has no save or restore function, and this is the point its forum threads return to most. A link you draw is live state in the running PipeWire graph. While everything stays connected it holds, but it is not written anywhere as your configuration. When a device disconnects and returns, a stream restarts, or the machine reboots, WirePlumber rebuilds links from its own rules and remembered stream preferences, and your manual wiring is not part of that rebuild. The graph comes back with the session manager’s defaults, not your patchbay layout.
That behaviour is consistent once you see the division of labour: the session manager owns automatic routing, and a patchbay edits the current session. PipeWire’s older session manager, pipewire-media-session, behaves the same way in principle. For a layout you need every day, the durable routes are the ones designed for persistence: WirePlumber configuration and stream rules, virtual sinks defined in configuration so the endpoints always exist, or qpwgraph’s maintained patchbay. Helvum remains the fastest way to build and fix a layout, and many use it to prototype a wiring scheme before encoding it somewhere permanent.
Installing Helvum
Helvum is packaged by the major distributions, so the normal route is your package manager: it sits in the Fedora, Arch, Debian and Ubuntu repositories under the name helvum, and a Flatpak build is published on Flathub. It needs a running PipeWire stack, which current distributions ship by default, and it works the same with the older session manager, since it talks to the graph rather than to the manager. There is nothing to configure afterwards: open it while a game and a chat client run, and the graph you see is the one you already have.
Gear that gives a patchbay something to route
A patchbay earns its place when a setup has several endpoints. These five pieces of streaming and voice gear show up as separate nodes in the graph and benefit from deliberate wiring.
Focusrite Scarlett 2i2 (4th Generation)
A two-input USB interface is where multi-node graphs start: its inputs and outputs appear as distinct endpoints, so a microphone or a console feed can each be wired separately.
Specs:
– Inputs: 2 XLR and line combo inputs
– Preamps: two 4th-generation Scarlett mic preamps with Air mode
– Features: Auto Gain and Clip Safe
– Outputs: balanced line outputs and a headphone output
– Connection: USB-C, bus powered
Samson Q2U
The Q2U is a dynamic microphone with both USB and XLR outputs, so it can start as a simple USB node in the graph and later move onto an interface without replacing the microphone.
Specs:
– Type: dynamic handheld microphone
– Polar pattern: cardioid
– Outputs: USB and XLR
– Monitoring: headphone jack with on-mic monitoring
– Connection: USB plug and play, or XLR to an interface
Elgato Wave:3
A USB condenser microphone that appears in the graph as its own capture node. Elgato’s Wave Link mixer software is a Windows and macOS application; on Linux the Wave:3 works as a standard USB audio device, and Helvum plus virtual sinks cover the routing side of that job.
Specs:
– Capsule: 17 mm condenser
– Polar pattern: cardioid
– Sample rate: 48 or 96 kHz, 24-bit
– Feature: Clipguard overload protection
– Control: capacitive mute with LED indicator
Shure MV7+
Shure’s USB and XLR dynamic microphone for streamers and podcasters. Its DSP features are managed through Shure’s MOTIV Mix app on Windows and macOS; on Linux it works as a standard USB audio device, which is all a patchbay workflow needs.
Specs:
– Type: dynamic microphone
– Polar pattern: cardioid
– Outputs: USB-C and XLR
– Monitoring: 3.5 mm headphone output
– Features: Auto Level Mode and a built-in pop filter design
Elgato Stream Deck MK.2
Not an audio device, but the usual companion to a routing setup: fifteen LCD keys that streamers map to scenes and track layouts, so the patchbay wiring and the capture layout change together. Elgato’s own software targets Windows and macOS; Linux users run it through community software.
Specs:
– Keys: 15 customisable LCD keys
– Connection: USB-C with detachable cable
– Design: interchangeable faceplates, removable stand
– Use: scene, source and macro control for streaming software
How to choose
Choose Helvum if your routing changes are occasional and visual: splitting a stream layout for one recording setup, re-pointing a chat client at a processed microphone, or checking why a game is silent. Choose qpwgraph instead if the same layout must be re-applied automatically at every login, because its saved patchbay is built for exactly that. Choose neither, and use session-manager rules alone, if your setup is one headset and one microphone that never changes; the defaults already do that job.
Who should skip
Skip Helvum if you expect it to fix sound rather than routing: it has no effects or processing of any kind, so look at an effects host instead. Skip it if you need a layout that restores itself untouched after every reboot and device swap, unless you pair it with the persistent configuration described above. And skip the patchbay idea entirely if you never run more than one audio application at a time; there is nothing to rewire in a graph with one stream.
FAQ
Does Helvum work with PulseAudio applications?
Yes. PulseAudio applications run on PipeWire through its compatibility layer and appear in the graph as ordinary nodes, so they can be wired like any other stream.
Will my Helvum routing survive a reboot?
No. Links are live session state, and the session manager rebuilds the graph from its own rules at login. For a permanent layout, use WirePlumber rules, configured virtual sinks, or qpwgraph’s saved patchbay.
Can Helvum send one game to two places at once?
Yes. A node can hold several links, so a game can feed both your headset and a recording sink at the same time, which is the basis of most split-track streaming layouts.
Is Helvum only for audio?
No. It draws the PipeWire graph generally, which includes video nodes such as cameras, so capture sources can be inspected in the same window, although most gamers use it for audio.
Final verdict
Helvum does one job and does it cleanly: it shows you the PipeWire graph your games already live in, and lets you rewire it by dragging cables instead of editing configuration. Its limit is equally clear, because nothing it draws is saved, and anyone who needs persistence should treat it as the design tool and put the finished layout into session-manager rules or qpwgraph. For streamers splitting tracks and players untangling microphone chains, it is the quickest route from a confusing setup to a picture that explains itself.











