Electric guitar interface setup

This article or section needs language, wiki syntax or style improvements. See Help:Style for reference.

Reason: Section headings should use sentence case, some section links are broken. (Discuss in Talk:Electric guitar interface setup)

This guide covers setting up your electric guitar with Arch Linux to achieve professional, low-latency audio processing using primarily Free and Open-Source Software (FOSS). It is designed for live playing and can be extended for recording.

Introduction

Playing electric guitar through a Linux computer is a three-step pipeline:

1. Instrument-level signal from the guitar pickup 2. Low-latency digital conversion by an audio interface 3. Real-time processing by FOSS amp/FX software

This guide is a single entry-point that gets you from “I just plugged my guitar into Arch” to “I hear a cranked 5150 in < 6 ms” without leaving the free-software ecosystem. It is aimed at live playing, not recording, so every setting is optimised for the lowest round-trip latency that your hardware can stably deliver.

Required packages

Core tools (official repositories):

alsa-utils – command-line ALSA control
ardour – full-featured DAW for lowest-latency hosting
carla – modular plugin host and patch-bay
guitarix – virtual guitar amplifier
gxplugins.lv2 – extra LV2 plugs from the Guitarix project
pipewire pipewire-alsa pipewire-jack pipewire-pulse – unified low-latency audio server
qpwgraph – PipeWire/JACK connection manager
rakarrack^AUR – multi-effects processor
realtime-privileges – rtprio & memlock rules
tuxguitar^AUR – tablature player/viewer (useful for backing tracks)
wireplumber – PipeWire session manager
pavucontrol – classic PulseAudio mixer (still handy)

Extra utilities (AUR):

kpp — Kapitonov Plugins Pack – profile-based guitar amps & cabs.

https://github.com/olegkapitonov/Kapitonov-Plugins-Pack || kpp^AUR

ratatouille-lv2 — Neural amp & IR loader (NAM-compatible).

https://github.com/juce-framework/JUCE || ratatouille-lv2^AUR

smartamp — Machine-learning amp modeller.

https://github.com/keyth72/SmartGuitarAmp || smartamp^AUR

guitarix.vst-git — Guitarix as VST3 plug-ins.

https://github.com/brummer10/guitarix.vst || guitarix.vst-git^AUR

If you only want to jam, skip to #Quick start. If you already own a Real Tone Cable and want to use it inside Rocksmith 2014, see Rocksmith 2014 on Linux instead.

Hardware Requirements

Audio Interface

The built-in sound card of most computers is unsuitable for direct guitar connection. Its inputs (microphone or line-in) are not designed for the high-impedance signal from guitar pickups, resulting in poor sound quality.

- Solution:** You need an external audio interface with a dedicated instrument-level (Hi-Z) input.

Recommended (2025): These are affordable, reliable, and work flawlessly with Linux out-of-the-box.

   *   `Focusrite Scarlett Solo (4th Gen)`
   *   `Arturia MiniFuse 1`

Alternative: Many guitar multi-effect processors (e.g., `BOSS GT-1`, `Line 6 POD`) can also function as USB audio interfaces, allowing you to blend their built-in effects with software plugins.

Connection

Plug your guitar into the instrument input on your audio interface.
Connect the interface to your computer via USB.
Connect your headphones or studio monitors to the audio interface's output.

System Configuration for Low Latency

Achieving low latency (<6ms) is critical. Follow these steps:

1. User Groups & Privileges

Add your user to the `audio` and `realtime` groups for low-latency scheduling:

# usermod -aG audio,realtime $USER

Create `/etc/security/limits.d/audio.conf` to grant necessary privileges:

/etc/security/limits.d/audio.conf

@audio   -  rtprio     95
@audio   -  memlock    unlimited

Reboot to apply group membership and ulimit settings.

2. CPU Governor

Set your CPU governor to `performance` to prevent frequency scaling delays:

$ sudo cpupower frequency-set -g performance

(Make this persistent across reboots by configuring your init system or desktop environment.)*

3. Reduce System Load

Close unnecessary applications, especially web browsers.
Disable Wi-Fi if possible (e.g., `sudo modprobe -r ath9k` for `ath9k` drivers).

Audio Server Setup (PipeWire)

PipeWire is the modern standard, replacing JACK for most users. It provides excellent low-latency performance while allowing multiple applications to share the audio device.

1. Configure PipeWire

Copy the JACK compatibility configuration:

$ mkdir -p ~/.config/pipewire
$ cp /usr/share/pipewire/jack.conf ~/.config/pipewire/

Edit `~/.config/pipewire/jack.conf` to set your desired latency. For example:

~/.config/pipewire/jack.conf

# global properties for all jack clients
jack.properties = {
    node.latency = 128/48000 # Buffer size/Sample Rate. Try 64/48000 or 128/96000 for lower latency.
}

2. Set Pro Audio Profile

Use `pavucontrol`. Go to the "Configuration" tab and set your audio interface's profile to Pro Audio. This disables unnecessary software mixing and puts PipeWire into a low-latency mode.

3. (Optional) Dynamic Sample Rate

You can dynamically change PipeWire's sample rate and buffer without restarting:

$ pw-metadata -n settings 0 clock.force-rate 96000
$ pw-metadata -n settings 0 clock.force-quantum 128

Running Guitarix

1. Launch `guitarix`. 2. Launch `qpwgraph` (the PipeWire patchbay). 3. In QPWGraph, create the following connections:

   *   Your audio interface's input (e.g., `capture_1`) → `guitarix:in_1`
   *   `guitarix:out_1` → Your audio interface's output (e.g., `playback_1`)
   *   `guitarix:out_2` → Your audio interface's output (e.g., `playback_2`) (for stereo)

4. Start playing! You can now load amp models and effects within the Guitarix interface.

Advanced Setup: Using a DAW for Lower Latency

For the absolute lowest latency and more flexible plugin chaining, use a Digital Audio Workstation (DAW) like Ardour or Reaper and load the `gxplugins.lv2` or `kpp` plugins directly.

Why use a DAW?

Lower Latency: DAWs like Ardour and Reaper are optimized for ultra-low latency, often outperforming standalone applications like Guitarix.
Flexible Routing: Easily chain plugins in series or parallel on different tracks.
Recording Ready: Seamlessly transition from live playing to recording.

Installation & Setup

# pacman -S ardour # For FOSS
# OR
$ yay -S reaper # For the commercial (but highly recommended) option

1. Launch your DAW (Ardour/Reaper). 2. Create a new project. 3. Select Audio Backend:

   *   For absolute minimum latency, choose `ALSA` (this will lock the audio interface exclusively to the DAW).
   *   For flexibility, choose `JACK` (which will use PipeWire under the hood).

4. Configure Buffer Size: Start with `128 samples @ 48000 Hz` or `64 samples @ 48000 Hz` and decrease until you find the lowest stable setting (no audio glitches or xruns). 5. Create an audio track. 6. Add your desired LV2 plugins (e.g., `gx_amp`, `kpp_tubeamp`) to the track's insert slots. 7. Use `qpwgraph` to route your audio interface's input to the DAW's input track, and the DAW's master output to your speakers.

DAW-Specific Optimizations

Ardour:

   *   *Edit > Preferences > Audio > Backend:* Choose `ALSA` or `JACK`.
   *   *Edit > Preferences > Performance:*
       *   Set "Denormal Protection" to `Flush to Zero and Denormals are Zero`.
       *   Set "Power Management" to `Lowest (prevent CPU sleep states)`.
       *   Experiment with "Processor Usage" settings (e.g., "Use 1 processor").

Reaper:

   *   *Options > Preferences > Audio > Device:* Select your interface.
   *   *Options > Preferences > Audio > Buffering:* Reduce "Request Block Size" (e.g., 128 or 64 samples). Disable or limit "Allow live FX multiprocessing".

Alternative Software Hosts

MOD Desktop: A web-based, user-friendly pedalboard interface with 200+ built-in plugins, including neural amp sims (AIDA-X, NAM). Great for beginners.
Carla: A powerful modular host supporting all plugin formats, but can have higher latency and a less intuitive GUI.
Bespoke Synth: Excellent GUI and patching capabilities, though more synth-focused.

Measuring Real Latency

Do not trust software-reported latency! Measure the *real* roundtrip latency:

1. Connect a cable from an output of your audio interface back to an input. 2. Load the LSP Latency Meter plugin in your DAW or host. 3. Send a test signal and measure the delay. This is your true system latency.

Troubleshooting

mlockall failed error: Ensure you completed the #Ulimit step and added your user to the audio group.

High latency / xruns (glitches): Double-check all #System configuration for low latency steps.; Increase the buffer size in your DAW/host or PipeWire config.; Close background applications.; Try a different kernel (e.g. linux-lts, linux-xanmod^AUR).; Confirm the Pro Audio profile is selected in pavucontrol.

No sound / device not found: Verify physical connections.; Check pavucontrol > Configuration and Input/Output Devices tabs.; If using ALSA backend in a DAW, ensure no other application is using the device.