Gig Performer 4

A typical mid‑gig view of Gig Performer. The main stompbox‑like controls are built from a range of knobs, buttons and other objects provided in the app, all mapped to plug‑ins running in the background. In this Setlist view, the preconfigured list of songs and song parts can step through variant or even wildly different setups, instantaneously and glitch‑free.

Gig Performer is a live plug‑in platform that’s as configurable as it is crash‑proof.

Modern, powerful laptops running software instruments and effects hold lots of promise for live use. You’ll need the right software for the job, though, if you don’t want the experience to get messy, and that’s where Gig Performer comes in. Since its first release in 2016 it has gained a reputation for both flexibility and crash‑resistant robustness, and it’s one of the very few applications in this relatively niche software area that’s available for both macOS and Windows. What else does it offer, and could it really let you abandon your hardware on stage?

Basics

At its core, Gig Performer is a plug‑in host: it’ll open 64‑bit VST and VST3 plug‑ins in Windows, and also Audio Units on the Mac. Just as much, it’s an environment in which to connect those plug‑ins with the outside world, handling all sorts of signal inputs and outputs. It can use multiple channels of a connected audio interface, and multiple MIDI devices such as controller keyboards, control surfaces, pedalboards and hardware synths. It’s also compatible with the OSC (Open Sound Control) protocol, letting you build custom control surfaces for it in suitably equipped third‑party iOS and Android apps.

Signal flow in the program is displayed and configured with a virtual wiring view. End‑to‑end connections — from audio and MIDI inputs, through instruments and effects, to eventual outputs — are clearly and intuitively displayed, with colour‑coded blocks and virtual, draggable wires connecting them together. The blocks have little dot symbols representing inputs and output ports, and there’s nice flexibility here, with the outputs capable of splitting signals and inputs merging them, when multiple wires are connected. For more complex and ambitious setups, some dedicated utility plug‑ins are provided: MIDI processors, mixers, gain controls, media players and more. Double‑clicking a block opens controls for it in a floating window, ranging in complexity from one or two simple faders to full plug‑in interfaces.

The Wiring view, however, is conceptually only the place where you build your live rigs. For on‑stage use it’s intended you’ll work in the Panels and/or Setlists view. These typically show a simplified front end for the underlying setup, using the familiar visual paradigm of a virtual rack unit. You get to choose the appearance, building control surfaces from a range of virtual knobs, sliders, buttons, switches, labels, LEDs and meters, which are linked to plug‑in parameters, or send other commands. If that sounds quite labour‑intensive, well, yes, it has the potential to be. In practice it’s not, though, because the trick is to expose just those few parameters you’ll really need in the heat of the moment. The resulting chunky, high‑vis ‘large print’ look is potentially then a real advantage on stage.

What lies beneath... The same rackspace as that shown in the fist screen, in its Wiring view, with windows open for one of the bundled virtual instruments and the powerful MIDI In block, which can perform all sorts of processing and filtering, and set up keyboard splits and velocity switches.

Panel controls (known as Widgets) can be manipulated with mouse clicks and drags, but for stage use can be driven by MIDI and OSC messages too, allowing you to tie them to a MIDI keyboard or floor unit in remote‑control fashion. The relationship between a knob, say, and the plug‑in parameter it controls can be complex: it could have its value range reversed, constrained, or scaled in a logarithmic, exponential, stair‑step or other user‑defined relationship. There are also facilities for handling hardware controllers with both standard knobs/pots and endless encoders using several different value‑increment schemes.

We’re nearly there with Gig Performer’s core concepts, but the last few are particularly interesting for performing musicians. First, any virtual rack design, and the concoction of plug‑ins behind it, is called a Rackspace. Many of these, dozens if necessary, can be loaded at one time into a single Gig Performer ‘.gig’ file, and while only one Rackspace is active at a time, its neighbours stay in a state of readiness. That means Gig Performer can do what various stage keyboard manufacturers call ‘seamless’ or smooth sound transitions — here it’s known as Patch Persist — so that currently sounding virtual instrument notes (or indeed delay or reverb effect tails) are not cut off when you switch to another Rackspace, which itself will load without a delay or any audible glitches. This gives the possibility of associating different (and perhaps wildly different) Rackspaces with different songs in a set, and moving instantly between them.

An associated feature, Variations, lets you save different settings for a single Rackspace, like automation snapshots. This comes into its own when you have a single Rackspace that does and has all you need (think guitar pedalboard for example) and you only need to bypass some plug‑ins or tweak settings for different parts of a song.

Following logically on from these, there’s Setlists. In another dedicated view mode, you’re able to formally build a sequential list of the musical numbers (or ‘songs’ in Gig Performer parlance) you’re intending to perform in a live set, and break them down into sections (Intro, Verse, Chorus, and so on) if you like. Each of those can then be easily associated with its own Rackspace or variation, with their names unambiguously displayed in the application window along with a prompt of what’s coming next. Gig Performer can also broadcast MIDI bank and patch changes to external keyboards and other devices, as songs load.

The editing view for a Rackspace. Notice the knob selected at the lower left of the rack, the properties and plug‑in mappings beneath, and the alternative ‘widgets’ in the list on the left.

On The Road

So that’s the core of Gig Performer: it’s certainly extensively equipped for its role. What’s it like to actually use? Broad‑brush stuff first: the operational style is notably open‑ended and extremely configurable. At the same time, there’s good user‑friendliness and first‑class documentation, and I found getting going really easy, with no arcane concepts or clunky interface surprises. There’s often the feel of more ‘traditional’ software design, with reliance on multiple additional floating windows, and somewhat varying styling across the different operational modes. That’s not the modern, minimal way for touch‑driven interfaces like iOS and Android, and so it doesn’t surprise me that currently Gig Performer isn’t available for those operating systems.

Still, for the task at hand it’s what the app can do that’s important, not how cool it looks, and all the basic stuff — from adding plug‑ins to creating Rackspace widgets and assigning hardware controls — is quick, straightforward and clear in practice. I appreciated the fact that it’s entirely possible to start with a completely clean slate. It’s also great that Gig Performer addresses MIDI and audio hardware directly, and only using those channels and devices you actually need, cutting out OS‑level involvement (such as macOS’s Audio MIDI Setup application).

And at the risk of largely concluding this review some way before the end, I can confirm that reputation for reliability. I spent several weeks with Gig Performer trying all sorts of setups with as many permutations of internally hosted software instruments, hardware synths, audio interfaces and MIDI controllers as I could muster. I could not catch it out: it never crashed or hung, did anything weird, or failed to do something when it should. I’d have needed a lot longer to explore even a majority of conceivable setups and permutations of plug‑ins, but I get the strong impression the outcome would be exactly the same. As an aside, It’s notable and reassuring that there are large and active online communities of Gig Performer users reporting the same experience. User support from the company seems to be quick and helpful too. There looks to be a lot of happy people in the Gig Performer user base...

So, the basic functionality is very much fit for purpose. In addition, though, there’s a lot of unseen (and somewhat unsexy) features that will be worth their weight for many users. I’ll rattle through a few.

One is called Rig Manager. This adds a layer of abstraction between controls on physical MIDI gear and the software knobs and sliders within Gig Performer. Practically, it lets you do easy control remaps if you plan to (or indeed are forced to) change your hardware MIDI controller at some point, or even regularly, as you move between a home studio and live touring setup.

Then there’s the way GP handles missing plug‑ins and mismatching audio interface channels and models, when that situation arises. In both cases it substitutes placeholders, so you can continue to work, and save your work, without losing original settings. Whilst we’re on the subject, document saving itself is unusually sophisticated. You can choose to save only individual Rackspaces, while discarding others that were perhaps unsuccessful experiments.

Even further down at the deep end of the feature set are two methods of sophisticated customisation. One is a built‑in scripting language, GPScript, which can add a huge amount of functionality over and above built‑in features. Some provided examples show it creating chords from single notes, building crossfaders, and it can extend MIDI capabilities too. Yet more is possible via Extensions — programmer‑level stuff, but open, accessible and documented — which can rejig the user interface or build brand new functionality.

Getting back to more hands‑on use, one of the most powerful features introduced in version 4 is the Streaming Audio File Player. This Wiring‑view block loads up one or multiple stereo audio files in MP3, WAV, AIFF, FLAC, OGG and many other formats: useful in itself for playing backing tracks, transitional material between songs, or sound effects. However, sections can be looped, and markers added that will automatically trigger what are called Timeline Actions. They include loading Rackspaces, variations or songs, sending various MIDI or OSC messages, and triggering lyric or chord symbol display in a dedicated window. It’s essentially time‑based automation, easy to use, and with the potential to smoothly automate an entire backing track‑based set. Ramp‑type parameter value changes aren’t supported — it’s about discrete events rather than DAW‑style state changes — but it has potential to do heavy lifting for quite sophisticated shows.

The Streaming Audio File Player lets you play back audio in a wide range of file formats. You can also sync actions to its timeline: here the arrival at ‘Chorus 2’ marker automatically switches to a different rackspace.

Surprising too, perhaps, are some sampling‑related features. Two wiring blocks, Auto Sampler Generator and Auto Sampler Recorder, automate the MIDI triggering, audio recording, and subsequent file naming and saving required to create a set of samples from an internally hosted software instrument (and any associated effect chain) or indeed an external synth hooked up to your audio interface. The idea is to replace CPU‑intensive plug‑in chains or hardware synths you don’t want to take on stage with lean‑running sample replay. It can be quite sophisticated, too, with velocity switching, though no automatic looping. The resulting sample file sets are generic enough to be loaded into most sample replay software worth its salt, but there’s an option to automatically create a preset for the third‑party freeware sample player, Decent Sampler.

Giggity

Designing software that has immense potential and flexibility but is easy to use from the get‑go is no mean feat. But that’s exactly what has been achieved with Gig Performer. It’s blindingly obvious that it has been conceived by people who do actually play live.

Criticisms? Nothing specific or serious from me, but perhaps a few thoughts that potential users and buyers might want to take on board while they’re waiting for the 14 day (almost) fully functional trial to download.

The first is about the fundamental nature of gigging software like this. When I began setting up my first soft‑synth‑based Rackspaces, I wondered about how presets and patchlists would be handled. In short, presets can’t be changed directly from panel controls. It’s neither a fault nor a weakness, and the logic behind it is sound: switching patches within a plug‑in can take time, especially if sample loading is involved, and cause glitches. The solution is to use multiple Rackspaces, each with an instance of your instrument, preconfigured with the patches you need. The point is, this might require quite a shift in thinking compared to most DAW, hardware synth and effects pedal workflows, and whilst the Wiring view gives you unfettered access to plug‑in windows with their preset choosers and other facilities fully intact, you’ll get best results by converting to this rather more deterministic way of working, for your big night.

Similarly, there is nothing in the application that looks much like an analogue mixing desk. That’s in stark contrast to one of Gig Performer’s main competitors, Apple’s Mainstage. There, Logic lookalike channel strips are available by default, equipped with plug‑in slots, pans, faders and sends. Equivalent signal flows can certainly be constructed in Gig Performer — more complex ones in fact — and the mixer‑less approach seems to be very much a conscious (perhaps guitarist‑leaning) design choice, prioritising the clarity of linear signal flows over typical mixer aux/bus structures.

The flip side to that clarity, though, is that Gig Performer’s Wiring view often leaves you building basic infrastructure from scratch. For example, setting up processing for an incoming vocal signal might involve adding EQ, gate and compressor plug‑ins and wiring them appropriately. Easy enough, but it’s unfortunate that there are not even basic versions of those amongst the bundled internal plug‑ins. If you don’t happen to own one in the form of a third‑party plug‑in (which is far from inconceivable — I discovered I had loads of dynamics plug‑ins but no simple third‑party EQs) then it’ll be off to the Internet for you... Compare that to a Mainstage channel strip, which provides all those basic facilities by default, as well as familiar level and pan controls, and Gig Performer can definitely end up feeling harder work.

It’s not a question of better or worse, and it’s far from an insurmountable problem. Also it would be remiss of me not to point out that another major player in this field, the Windows‑only Cantabile Performer, is in practice more or less text‑based, with neither wiring views nor channel strips. So it’s a matter of style and implementation more than anything.

Having spent a lot of time with it now, I certainly would trust it in a live situation.

Caveats around signal flow paradigms aside, though, I’ve got nothing but praise for Gig Performer. The more I used it, the more I enjoyed and admired it. Unarguably it has more advanced features than its competitors, and having spent a lot of time with it now, I certainly would trust it in a live situation. Which, speaking as a largely hardware‑reliant dinosaur who’s had his fingers burnt by software on stage before, is quite something.

Gig Performer is unusual, but it’s exceptionally good at what it does. With laptops as powerful and relatively affordable as they are these days, it could be as good a reason as any to commit to a software‑based live rig.