AudioMulch's unique take on music creation and sound design already has many loyal fans. Will the new version 2, which adds Mac compatibility for the first time, win it a fresh army of admirers?
AudioMulch, a piece of audio software developed by Ross Bencina in Melbourne, Australia, is officially described as an "interactive music studio” offering support for live electronic music performance, composition and sound design. The market is awash with applications aimed at a similar niche, so where does AudioMulch fit in the ecosystem of modern computer‑based music, and how well does it stack up?
A few glances at typical screenshots reveal the knobs and faders of synthesizer control panels, alongside an editing panel where objects are connected by patch cords, which suggests that we are in modular synthesizer territory. But AudioMulch also features an automation system that supports MIDI or real‑time recording and can be locked to MIDI beat clock, hinting at something akin to an audio sequencer — except that there are no waveform displays anywhere to be seen.
In fact, AudioMulch is more like an attempt to fuse several domains and working styles: it can be used for modular synthesis, and it can be used — after a fashion — for audio multitracking. But the automation system, as we shall see, is also geared towards what might be called score‑based sound composition, with discrete control events planted in the timeline. Add some rather unusual granular synthesis and filtering modules to the mix, and we might almost find ourselves in electroacoustic territory. This might sound a bit scary, but the user interface looks warm and inviting, so why don't we give it a shot...
AudioMulch began life as a Windows‑only development effort in 1998, culminating in the release of version 1.0 in 2006. (Sound On Sound briefly reviewed a shareware beta version in October 2004.) Version 2.0 is a comprehensive rewrite, offering Windows and Macintosh compatibility and a major face‑lift. Mac users should note that the application is not a Universal Binary, and requires an Intel processor — it won't run on Power PC machines.
AudioMulch is available to purchase by download only: as it's a svelte 20MB package including machine‑readable manual, it makes little sense to manufacture CDs and ship them in boxes (especially from Australia!). Prior to licence activation, it runs as a fully enabled demo for a generous 60 days, and licences are transferrable between computers. The application comes with a handful of audio samples (mostly percussion), a few dozen examples, and fully integrated documentation, and there is no complex installation process.
On launch, AudioMulch creates a new default document, ready for editing. By default, the application also opens the hyperlinked help system, so it's possible to jump immediately into the manual or the help pages. AudioMulch can open one document at a time: in this regard, it's more like a DAW than a toolkit such as MaxMSP, although it has a definite toolkit look and feel. The user interface is heavily customised and is presented with white text against various shades of grey. The text is anti‑aliased and all the components have a smooth, rounded, gradiated appearance — nicely designed, and a real step up from the primitive, dated look of the earlier Windows release. Visually, the application has a lot in common with the latest MaxMSP, and is likewise built with a platform‑independent toolkit (Qt, rather than JUCE as used by MaxMSP), so the AudioMulch experience should be pretty identical on Mac and Windows.
AudioMulch's document window is divided into three panes: Patcher on the left, Property to the right, and Automation at the bottom. The Patcher and Automation panes can undocked as floating windows, redocked elsewhere, or closed entirely to just leave the Property area accessible, but in practice most users will probably stick with the default layout. Additionally, the Patcher pane is split into an editing area alongside a browser showing AudioMulch's audio building blocks.
The term 'Patcher' is immediately reminiscent of MaxMSP, and AudioMulch's Patcher works in a very similar way to Max's, so Max users will feel right at home. Audio objects — AudioMulch refers to them, rather charmingly, as 'Contraptions' — can be placed in the Patcher pane by dragging from the browser. Contraptions are drawn as boxes with audio inputs on top and audio outputs on the bottom, and can be wired up with patch cords by dragging with the mouse between inputs and outputs: again, very much in the MaxMSP mould.
At this stage it's worth noting that AudioMulch's patching environment is much simpler than that provided by MaxMSP: whereas Max can pass and process messages representing numbers, text, audio and video, AudioMulch works almost exclusively in the audio domain (we'll look at MIDI later), and practically all patch cords carry audio.
Unlike MaxMSP, AudioMulch forcibly separates the layout of audio Contraptions from their user interface: interface components live in the Property pane. Most Contraptions have a corresponding Property panel, and these can be displayed and organised in the Property pane independently of the patching layout, forming the main user interface of an AudioMulch document. The Property panel for each kind of Contraption has a fixed, predetermined layout; in fact, the best way to distinguish between Contraptions of the same type is to give them meaningful names. Unlike MaxMSP, AudioMulch provides no facilities for creating custom user interfaces, apart from the intriguingly‑named Metasurface, which we'll describe later.
The set of available Contraptions is also completely fixed: there is no way to add new kinds of audio processing elements, apart from using VST plug‑ins, as I'll describe later. What's more, there is no way to encapsulate Patcher setups as components in new documents, or to refer to one document from another: the AudioMulch world is very much flat, with a palette limited to what's initially on offer. (This is not necessarily a bad thing: synthesizer hardware, and a lot of software, is similarly limited, but can still provide a huge amount of creative scope.) There is a MIDI‑controllable document-switching panel, however.
Since the patching interface and the Property panels are separate, the Patcher pane doesn't have to be 'locked' in order to operate the controls. This means that everything in AudioMulch is active and editable all the time, during audio processing and playback, with the aim of providing a clean workflow, and perhaps even encouraging forays into the currently hip activity of 'live coding'. I certainly found the user interface to be smooth and slick, making it easy to get into a creative flow.
AudioMulch has a familiar‑looking icon bar including transport controls, a bar counter and a tempo indicator, suggesting that it operates like a sequencer. In fact, a lot of the audio‑processing machinery will work whether this notional sequencer is running or not (which is perhaps disconcerting for DAW users), although it is necessary to activate audio processing by clicking the loudspeaker icon. However, many of the audio components are rhythmic in nature and want to synchronise themselves to bar and beat information, and this can only take place when the transport is running. The transport controls become more significant when we look at automation. Fans of complex time signatures should note that AudioMulch only operates in 4/4 time; machinery for other time signatures is planned in a future update.
Audio applications are generally interesting only when they can generate sound. AudioMulch can drive multi‑channel audio interfaces, both for input and output, but it has no other audio interfacing facilities: it cannot, for example, run as a ReWire client.
A Contraption called SoundOut routes a stereo signal to your audio interface's main outputs (although you are free to repatch outputs as you wish). A separate set of Contraptions called AuxOut1, AuxOut2 and so on routes audio to other stereo output pairs. Correspondingly, SoundIn, plus its siblings AuxIn1, AuxIn2 and so on, deal with audio input. SoundIn and SoundOut are rather special: they are capable, respectively, of reading from and writing to audio files, making it easy to reconfigure a 'live' AudioMulch document as a file recording or playback tool. (In addition, there are dedicated file recording and playing Contraptions, described below.)
A minimal AudioMulch application like a mixer would just have a SoundIn plus some AuxIn Contraptions at the top of the Patcher panel, a SoundOut plus some AuxOut Contraptions at the bottom, and some gain or mixing Contraptions in the middle, patched together in an appropriate manner. Things get to be more fun with the addition of some of the more interesting audio‑processing Contraptions, some automation curves and a bit of MIDI control. Let's take a look at what's on offer.
AudioMulch comes with several dozen different kinds of Contraption, which it classifies into input/output, signal generators, effects, filters, mixers, buses, and VST instruments and effects. Many of the Contraptions are similar to plug‑ins you'd find in typical DAWs, so there's no real need to describe things like the phaser, flanger, ring modulator or frequency shifter here. Other Contraptions are a little more unusual, and betray AudioMulch's beginnings as a platform for electroacoustic performance, with an emphasis on processing live audio input. However, alongside some seriously highbrow audio effects reside a drum machine and an emulated analogue monosynth with step sequencer, so there is some rhythmic fun to be had. Also, since AudioMulch isn't actually an audio sequencer, there's a set of Contraptions for dealing with recording and playback of audio files, which is as close as we get to real audio multitracking.
The file-player Contraptions do much as you'd expect: they stream audio from sound files on disk. There is an option for looping a file, plus an auto‑rewind option, which is useful for retriggering the same file from the beginning. Aside from the plain stereo FilePlayer, there are multi‑channel versions from 4FilePlayer up to 32FilePlayer, which are capable of playing heterogeneous combinations of multi‑channel files (from mono upwards) in synchronisation — handy for those B‑Format surround mixes you've been dying to use, but also handy to simulate multi‑channel playback from a combination of sources. File playback is at unity speed only: there's currently no tuning of playback pitch, and definitely no playback in reverse. File formats are limited to AIFF and WAV, with no support for lossy compressed formats such as MP3, nor for the Mac's slightly antiquated Sound Designer 2 format.
The file recorder Contraptions are the file‑writing components corresponding to the FilePlayers. Again, there is heterogeneous multi‑channel support, so a FileRecorder attached to a FilePlayer could be used to combine separate audio files into one multi‑channel file, or to split a multi‑channel file into mono or stereo components. Again, formats supported are AIFF and WAV, at 16-, 24- or 32‑bit resolution.
The file recorders have a 'SoundIn Sync' mode, which makes it possible to synchronise a recording pass to the playback of a source stereo file, turning AudioMulch into a kind of simple real‑time batch processor for audio files. This can be handy for applying gain or EQ tweaks to material that's already on disk.
When it comes to generating audio within AudioMulch, there are some intriguing possibilities:
Complementing the more serious sound‑design Contraptions are some more familiar sound sources, looking rather similar to those you might find in a conventional modular soft synth. There is a simple dual‑oscillator arpeggiator with a grid for triggers and ties. The grid length is always 32 steps and its time resolution is fixed at 16th notes, although the arpeggiation pattern can be reset at a programmable loop point. There is a glide control but no envelope shaping of the individual notes.
The Bassline Contraption is an emulation of a monophonic synthesizer, presumably the Roland TB303, with a 16‑note pattern sequencer: it offers accents and times on its notes, plus a resonant filter with LFO for cutoff modulation, and an overdrive effect. There's also a sequence randomiser. Bassline can be fed an audio signal, in which case the onboard oscillator is bypassed and the incoming audio is fed directly into the filter; the filter envelope is still triggered by the step sequencer.
Drums is a simple beat‑synchronised drum machine with eight step‑sequenced tracks, each of which can trigger a sound file. The individual sounds can have their respective levels mixed but they cannot be tuned, so any pitch alterations would have to be done with some other Contraption, and since an instance of Drums only has a monophonic output, individual parts would have to be lifted out into their own Drum instances. So don't expect to craft sophisticated rhythm sections without a bit of plumbing and processing at the Patcher level. (Sample tuning and multiple outs are planned for a future upgrade.)
LoopPlayer loads and loops an audio file, matching its timing to the current tempo. LoopPlayer needs to be told the notional length of the file as measured in bars, and will transpose it as required to synchronise with AudioMulch's transport controls. Note that LoopPlayer's tempo stretching is done by varying the playback rate (and hence pitch), rather than any kind of smart tempo warping.
There are two live looping Contraptions: CanonLooper takes an audio input into one recording track and then plays back delayed copies of that track in its other tracks, 16 in all. It takes a trigger signal to kick off the recording, further triggers to start playback of the delayed copies, and then another trigger to stop recording the first track (and hence to initiate looping). LiveLooper is similar, but can record audio into any of its 16 tracks, using chaining algorithms to step through the tracks automatically while recording. Both loopers are synchronised to beat and tempo.
As you would expect, AudioMulch is quite capable of combining and routing audio signals, with a collection of Contraptions for mixing and fading. There is a set of mixer objects for mixing multiple mono inputs to one mono output and mixing multiple stereo inputs to a stereo output, as well as panning mixers that combine multiple mono inputs, mixed and individually panned to stereo. The Crossfader Contraption provides a DJ‑style crossfader for two stereo inputs, while the so‑called Frosscader does the opposite, fading a stereo input between two stereo outs. There is also a pair of matrix routing objects — a 4x4 and an 8x8 — with programmable crossfade time.
Every Contraption's current Property settings are saved in the AudioMulch document, but each Contraption can also save its settings in its own table of up to 20 presets. Presets can be recalled manually, or via automation control or MIDI. A preset can be more than a handful of knob and fader positions: Contraptions that handle files will actually store file names in presets, so that a preset change can load a new file, and complex Contraptions like Drums, Bassline and the loopers generally save their entire state.
Presets can be cut, copied and pasted between Contraptions of the same kind, although there's no way to save a preset bank to disk. There is also no interpolation between presets: for that kind of parameter‑morphing action, AudioMulch provides the Metasurface, which is described in the box on the previous page.
The features we've looked at so far paint AudioMulch as something akin to a modular synth, albeit one with unusual features, such as the ability to read and write audio files. The transport controls and the Automation pane suggest a more linear personality, with the ability to compose and arrange along a timeline. In fact, in AudioMulch the Automation pane is the timeline — automation data is the only thing that can be recorded, edited and replayed on a linear grid — but AudioMulch's interpretation of 'automation' is more versatile than you might expect.
To start playing with automation, we open another pane called Parameter Control, which is accessible from the View menu or a button in the icon bar. Parameter Control is a document‑wide view of the control points for every Contraption in the Patcher, plus some pseudo‑Contraptions such as the Metasurface and the transport controls. Drill down into the parameter tree and you can enable individual parameters for automation. (MIDI control is also enabled here, as we'll see later.) When a parameter is enabled, it gets its own lane in the Automation pane.
Automation editing works much as in any other DAW. Breakpoints can be created, moved and deleted, and the usual cut, copy, paste editing operations are provided, as you would expect. AudioMulch supports multiple‑lane edits but, curiously, cut and delete always snip the selected time out of the lane(s) rather than removing events, and paste always inserts its data rather than overwriting. (An Insert Time command is provided to pad any regions that have been removed.) For comparison, Ableton Live provides time segment‑based and event‑based editing commands side by side, the default being event edits, so it strikes me that AudioMulch has opted for the less conventional choice as default. The issue is certainly not a show‑stopper, but is worth being aware of.
Automation lanes can be resized if you need to see events at a finer level of resolution, but there's no way to zoom in vertically, so subtle changes — a few Hertz in an oscillator frequency, for example — will often appear to be flat in the automation graph. Some way to rescale or normalise the automation display would be useful.
So far, so conventional, although there are some nice touches: for example, where a Contraption's parameter is a range rather than a single value, two automation graphs are displayed in the same lane, with the range visually highlighted between them. But things really start getting interesting when the automation system is used to hold discrete events. For example, the FilePlayer Contraption has an on/off button for playing back its file, and if this button is placed under automation, file playback is triggered along the timeline. The LiveLooper can be automated, such that different tracks can be selected for recording depending on position, and the Matrix routers can have individual cells enabled or disabled automatically. But most significantly, a Contraption's presets can be recalled by automation, so that entire sets of parameters, such as all the levels of partials in a 10Harmonics Contraption or the entire drum pattern (including samples) in a Drums Contraption, can be switched in one shot with a single event.
Viewed in this light, the automation window starts to look like a linear score, with discrete control events peppered amongst continuous fader curves. Event editing in the automation lanes can be quantised to any division of bar and beat, and dropping Contraption preset changes onto bar lines starts to look and feel suspiciously like laying out audio clips as a multitrack arrangement in a conventional DAW — but instead of audio data being cued for playback, AudioMulch is reprogramming audio components on the fly, synchronised to the beat. (One of the example documents is an entire song played purely from tracks of preset changes, resulting in a lovely mbira pattern.)
Finally, it's possible to loop an arbitrary section of automation (for all lanes at a time). This is obviously useful for auditioning and editing if you're using AudioMulch as a linear composition platform, but for sound design a looped automation section — especially if aligned to bars or beats — is a useful way to construct tonally interesting rhythmic material. Think of an automation lane as a very sophisticated LFO — and then think about how many other synthesizers let you use an LFO to switch presets in the middle of a note!
I was initially a bit disoriented by what seemed to be a rather arbitrary choice of built‑in sound generators — a drum machine and a Risset tone generator? — but if one approaches things creatively rather than analytically, the pieces start to slot together into a surprisingly smooth working environment. The audio Contraptions are efficient and sound clean and smooth: the granulators, for example, are tighter than some I've used (and most of those that I've built).
The lack of audio multitracking felt a bit odd at first, but I just had to 'let go' and think in terms of modular synthesis with a score, rather than multitrack recording. I was slightly unconvinced by the Metasurface 'on paper', but in practice it worked well, leading to interesting sonic territory — literally, in a sense — that wouldn't have been predictable.
As a seasoned user of both MaxMSP and Ableton Live, it wasn't immediately clear what — if anything — AudioMulch would be able to bring to my particular table. MaxMSP is the ultimate audio and video construction kit, while Live sets the standard as a loop‑based sequencing, mixing and performance environment. On the surface, AudioMulch is simpler, and generally weaker in terms of features and extensibility, than either. However, when it comes to creative tools, 'simpler' can often mean 'more focused', and what really matters is the choice of features, not their number, and how well they are designed and integrated.
AudioMulch presents a pretty shallow learning curve and it's possible to patch together an effects unit, or something to process an audio file, in a very short time. The user interface is very polished and intuitive, so anyone who is familiar with software instruments and has a smattering of experience with modular synthesis will be up and running pretty quickly.
Since AudioMulch cannot be integrated with other audio software (except as a VST host), I found myself wondering how I would actually work it into my live performances, which generally involve MaxMSP ReWired into Ableton Live. The obvious solution is to 'go native' and use AudioMulch in isolation: this is clearly one of its design aims, and with a decent MIDI control surface this is perfectly feasible, although the addition of MIDI generating and processing features would deliver a lot more potential using hosted VSTs. Alternatively, if you are attached to your current setup, AudioMulch's automation features turn it into an off‑line programmable generator of short, time‑based sound works that could be spun into a live set. I would personally love to see ReWire support, so that I could run AudioMulch in real time and feed its output into Ableton Live as part of a performance.
All in all, though, AudioMulch is a breeze to use, is capable of yielding some surprising but beautiful results, and is dangerously easy to spend lots of time with. Whether that is a good thing is really up to you!
Since AudioMulch hasn't been reviewed in SOS before, I've treated it as a new product, but for those who are already familiar with the program, here's what's new in version 2:
AudioMulch can map MIDI input to Contraption parameters. Generally this will take the form of MIDI Controller messages, but there's also the option of more esoteric control such as using the velocity of individual notes. Data is mapped according to MIDI input port and channel; there's a 'quick learn' feature for setting up connections in a hurry, and a more detailed configuration setup in the Parameter Control pane, where automation is configured. The minimum and maximum values for modulation can be set here, and there's also a handy breakpoint graph for setting up more complicated responses.
Automation can be recorded via MIDI. Automation lanes can be individually enabled for recording, via a button that effectively provides punch‑in and punch‑out. Automation can also be recorded by clicking and dragging on‑screen knobs and faders, if you don't have a MIDI controller to hand. Somewhat disappointingly, though, there is currently no undo function for recorded automation data, so recording runs are effectively destructive.
Audio processing needs to be enabled before automation recording will work, and MIDI input also has to be explicitly enabled. Conventional DAWs tend to do this by themselves, so this serves as a minor gotcha.
Every application has a flagship feature to make it stand out from its competitors. Ideally, said feature looks good, and AudioMulch's Metasurface is cool in appearance and execution. The Metasurface is a two‑dimensional navigation window that allows interpolated crossfades, or morphing, between Contraption parameters. Rather than using the existing preset machinery, the Metasurface uses 'snapshots', which can capture properties from all the Contraptions in the document. You can choose which properties are affected, although the snapshot machinery only works for numeric parameters. These snapshots, which can be assigned names and colours, are then dragged and dropped onto a rectangular navigation panel that has a joystick‑like crosshair cursor. As the cursor is moved around, Contraption parameters are smoothly interpolated between the snapshots the cursor is closest to. You can position the snapshots wherever you like in the navigation panel, depending on the combinations of snapshots you want to fade between, and the panel is tinted with colours that reflect where the snapshots are located. With some careful choice and positioning of shapshots, it's conceivable that an entire performance could be driven purely by Metasurface navigation — there's even a full‑screen mode for that purpose — and the navigation can even be captured and edited as automation data.
AudioMulch provides support for third‑party VST effects and instruments. (Audio Units support on the Mac is planned.) VSTs are treated similarly to the built‑in Contraptions, providing audio inputs and outputs in the Patcher pane and exposing their automation parameters. Each instance of a VST has a generic Property panel with one fader per parameter, and there's also the option of viewing a VST's own control panel. AudioMulch's preset machinery is capable of storing and recalling VST preset states, so preset changes can be automated. VSTs also receive clock synchronisation when the transport is running.
The Patcher pane displays VSTs with additional inlets and outlets for MIDI. AudioMulch isn't a MIDI sequencer, and its MIDI support is rudimentary, amounting basically to remote parameter control and automation recording, but there is some additional MIDI support for VSTs. A MidiIn Contraption can route external MIDI into a VST, and any MIDI generated by a VST can be routed into another one. AudioMulch has no MIDI generating or processing Contraptions, so if you want to do anything like MIDI step sequencing, you will have to find a VST Instrument that can generate MIDI data to do the job. Alternatively, there's nothing to stop you driving AudioMulch and any VSTs it's hosting from an external sequencer — AudioMulch can slave to beat sync — or you could adopt a truly old‑school approach and actually play a MIDI keyboard.