In this article, I discuss the concept of Return tracks in Ableton Live.

In Live, signal flow can go from a many to one arrangement. This is the idea of a Return Track.

But before I go into more of this idea, I want to frame this in a different perspective – that as a software programmer. To help me understand what return tracks are in Ableton Live, I put myself into the shoes of a software developer (I use to be one) who has to implement this feature. Hopefully, by doing so, it will help you too.

Lets start out with going back to basic mathematics for a moment. Recall that a function takes inputs and returns outputs. In your college days, you probably have seen it expressed like this:

1. `y = f(x);`

Functions can be used to relate to one another. Below we see that the value returned by function f is used as in input into function g.

1. `y = f(x);`
2. `z = g(y);`

Keep this frame of mind for the rest of the article.

Now lets switch gear to that of a software programmer. Lets suppose we have two Midi tracks that are a violin and a flute. Lets also have two audio tracks that are the vocals and a guitar. These four tracks are to be routed to a special track (called a Return Track). The return track can be viewed to act like a function to handle a special set of processing steps. This is just another way of saying, “take the outputs of all selected tracks, and send them to a track to use them as inputs”.

Code wise, it can look something like this:

1. `typedef int (*Effect)(Track *);`
2. ` `
3. `int function Echo(Track *t) {`
4. `  // Do echo processing with a track`
5. `};`
6. ` `
7. `int function Chorus(Track *t) {`
8. `  // Do chorus processing with a track`
9. `};`
10. ` `
11. `Mixer mixer;`
12. ` `
13. `MidiTrack violin;`
14. `MidiTrack flute;`
15. `AudioTrack vocals;`
16. `AudioTrack guitar;`
17. `AudioTrack drums;`
18. `ReturnTrack a;`
19. `MasterTrack master;`
20. ` `
21. `// Route Send type tracks to Return Track A`
22. `mixer.RouteTrack(violin, a, SEND);`
23. `mixer.RouteTrack(flute, a, SEND);`
24. `mixer.RouteTrack(vocals, a, SEND);`
25. `mixer.RouteTrack(guitar, a, SEND);`
26. ` `
27. `// Add effects processing functions for Return Track A`
28. `mixer.AddEffects(a, &Echo, &Chorus);`
29. ` `
30. `// Add other tracks`
31. `mixer.RouteTrack(drums, master, NORMAL);`
32. ` `
33. `// Add to mix stage`
34. `if (a.SendStage == "PRE") {`
35. `  mixer.PreFxAddTrack(a);`
36. `}`
37. `if (a.SendStage == "POST") {`
38. `  mixer.PostFxAddTrack(a);`
39. `}`
40. ` `
41. `// Now mix`
42. `if (mixer.byPass == FALSE) {`
43. `  mixer.UseFaders();`
44. `}`
45. `mixer.Mix();`
46. ` `
47. `// Send to master out device`
48. `mixer.Out(Master);`

Don’t worry too much about the pseudo code above. Try though, to understand the mindset in how a software programmer thinks when it comes to working in audio.

A Return Track does not accept audio or MIDI clips – only effects. It can have one or more audio effects associated with it. Think of it as a function that inside of it, can take on many different sub functions like delaying, reverb, etc. Each subfunction transforms the input to morph into a different output of the signal.

Pictorially:

In the code example above, we have Echo and Chorus devices. In the picture above, you can imagine these two operations being slotted into the blue FX chain box.

The order of processing is important. When we add an Audio Effect, it gets appended to the end of a processing list. Think of this arrangement as a processing pipeline. What input signal comes in first, gets processed first by that signal processing device and then that output gets passed onto the next phase in the pipeline. In this case, the output of the Echo device gets sent as the input to the Chorus device. The resultant is what comes as output from the Chorus Device.

It should also be noted that a Return Track isn’t limited to just accepting one track as an input. It can take on multiple tracks.

The benefits of using a Return Track is so that if you have many tracks that want to do the same effects and parameter settings all the others, you don’t have to individually go and set them up. You just route their outputs to one central Return Track to handle them all.

So lets say in the processing pipeline there are a bunch of parameters (say 10) that all need to be set for the Echo device. You spend a whole lot of time setting those 10 parameters just right. You surely don’t want to create 10 instances of the Echo effect by dragging and dropping them in the device panel do you? And, setting all those 100 settings (10 x 10)?

This saves you a lot of time and headaches, especially when you need to validate those settings before playing.

Now if you do need to have different parameter settings for the Echo for say the guitar, then you don’t route the guitar track to Return Track A. You create its own effect instance to be associated with it instead. This gives you the full flexibility to control things the way you want to and make life easier by grouping effects through one track.

You can think of a Return Track as a “processing effects track”. A function that takes inputs (other tracks) and outputs a summation of those tracks applied to a chain of common effects and parameter settings.

You don’t have to associate effects with a return track. You can just use it as a common way to set all tracks to the Return Track’s mixer controls. So for example, if all four tracks were to be used to play on the left side of a stereo channel, you use the Return Track’s panning knob. If you want to control the track volume of all four, you use the Return Track. You can Solo all four tracks and mute them as well.

## The Return Sends Knobs

For every Return track created, a Send knob will be displayed for each Audio, Midi, or Group track. Each return track gets its own alphabet assigned for its identifier (A, B, C, etc.)

In the configuration above, the Vocals, Guitar, Violin, and Flute have their Audio To outputs set to “Sends Only”. That routes their output to the Track A (Reverb). The Return Track A in turn sends its Audio To the Master. A really cool thing is that you can adjust each track’s Sends A fader knob for each track. So if you want the Vocals to be louder than the other three, you turn it up and the other three Send knobs to Track A down.

In the Master track, each Return Track has a Pre or Post fader button. The buttons are displayed in the same position and orientation as the Send knobs (which may be confusing at first if you don’t see it).

The Pre/Post setting determines if the audio signal for the Master track is before or after the FX chain processing.

Pictorially, you can look at it this way:

Each track also has Pre and Post effects. To get a sense of this, think of it as staging. Each stage has a bucket available to store water (audio data). The color of the water changes through each passing stage. The final stage is going through the mixer to take on the mixer fader control settings.

• The Pre Fx stage involves no effects processing. Essentially, the signal bypasses effects processing.
• The Post Fx stage involves flowing through the effects chain and taking into account the mixer adjustments.

## Summary

Use Return Tracks when you need to have two or more Audio or Midi tracks share a common set of effect devices with the same parameter settings.