Live Set Management in Logic Pro

When planning my live performance, my goal is to create a seamless and engaging experience without unnecessary pauses or interruptions. Initially, I intended to work on adapting the Logic Pro project for my song ‘Lose My Hope.’ However, since the project wasn’t downloaded, I decided to use this time to work on overall live set management instead . Here’s how I tackled the setup and some of the challenges I encountered along the way.

Combining Songs in One Project

Initially, I planned to build separate Logic Pro projects for each song, but I realised this would lead to clunky transitions. Switching between projects during a live set would mean waiting for files to load, which could kill the energy of a performance. Instead, I decided to combine all 10 songs into a single Logic project. This way, everything is pre-loaded, and I can focus on delivering a smooth performance.

Creating Modes for Instrument Assignments

Since each song requires different instrument setups, I needed a way to manage this efficiently. Logic Pro’s modes feature allows me to assign unique configurations to each song. I found a way to do it from this forum. Here’s how I set it up:

1. Parameter Assignment: I created a separate parameter for each mode change, assigning specific values (1 for Song 1, 2 for Song 2, etc.).

2. Dial Configuration: My MIDI controller’s dials send values from 1-127. I adjusted the ‘value change’ fields to only respond to values 1-10, ignoring the rest. While this works, it’s a bit sensitive and tricky to select the exact mode during a live performance.

3. Future Upgrades: Unfortunately, my current controller doesn’t support editing output ranges, but I’m considering upgrading to one with more customisation options.

   
   
   
   

Controller assignment modes for songs

Managing Tempo with the Timeline

Each song has its own tempo, time signature, and key, so I needed a way to ensure these settings update automatically. Here’s my solution:

1. Tempo Automation: I used Logic’s timeline view to set the correct tempo and time signature for each section of the project.

2. Markers: I placed markers in the timeline to correspond to the start of each song. Markers act like bookmarks, making navigation simple.

3. MIDI Assignment: I assigned a drum pad to move the playhead to specific markers, ensuring the correct tempo settings are applied for each song.

While I’m not incorporating transitions between songs yet, this setup lays the groundwork for future enhancements.

Tempo automation and markers in Logic Pro timeline view

Navigating Live Loops Scenes

To produce sound, I’m using Logic’s Live Loops view. Navigating between scenes posed a unique challenge since this view lacks marker functionality. Here’s how I addressed it:

1. Scene Selection with Dials: I assigned two dials on my controller to ‘select previous scene’ and ‘select next scene’. Turning these dials allows me to quickly scroll through scenes.

2. Colour Coding: I colour-coded the cells for each song, making it visually clear where each song starts. This is particularly helpful for quick navigation.

3. Current Limitations: At present, I haven’t found a way to automate scene selection directly to the start of each song. It’s something I’d like to explore further.

Reflections and Next Steps

This setup marks a significant step toward creating a polished live performance. While it’s not perfect, the workflow improvements—from combining projects to using modes and markers—are making my vision more achievable. My next steps will involve refining scene navigation and experimenting with transitions between songs to enhance the flow of the set.

By documenting this process, I hope it offers insight into how a live performance setup evolves over time. If you’re working on your own, I’d love to hear about your challenges and solutions!

Building a Live Set Part 2: Refining Scene Triggers and Logic Pro Controller Assignments

Today, I made great progress working on controller assignments for my live set. After troubleshooting yesterday’s issues, I’ve simplified my setup, creating a workflow that feels more reliable for live performance. Here’s how it’s coming together:

Solving Scene Triggers and Logic Pro Controller Assignments Mode Changes

My initial plan was to use Logic Pro's controller assignments "mode change" feature to dynamically reassign MIDI controller buttons for each section of the song. Modes work like folders that organise controller assignments, allowing the same button or drum pad to trigger different parameters in different modes. For example, the same drum pad could trigger "queue next scene" in the verse mode and "play the chorus synth" in the chorus mode.

To achieve this, I set up a "mode change" parameter so that triggering a drum pad would not only queue the next scene but also shift to the corresponding mode for that section. However, I ran into a chain reaction issue: the same drum pad, assigned to mode changes across all modes, seemed to skip from the first mode to the last. This might be because the MIDI data was creating a feedback loop, but I couldn’t pinpoint a solution.

Rather than spending more time debugging Logic Pro's controller assignments, I opted for simplicity: assigning two drum pads for next/previous scene triggers instead of using dynamic mode changes. This setup sacrifices some efficiency but offers more flexibility and control if something goes wrong during a live performance.

Attempt at dynamic mode changes for each section

Simplified Logic Pro controller assignments

Simplifying the Performance

Balancing live playing and scene triggers is challenging, especially when my hands are already full on the keyboard. To streamline things, I made a few adaptations to my keyboard parts:

• For complex melodies, I swapped out intricate note patterns for held chords during moments when I need to trigger scenes. This reduces the risk of errors and keeps transitions smoother.

Timing the triggers was another hurdle. At first, scene playback felt unpredictable, as I couldn’t figure out how early I needed to trigger the next scene. Enabling Logic Pro’s “Cycle Mode” and resetting the playhead before each run-through fixed the issue. Now, the quantised start times are more reliable, making it easier to stay in sync.

A failed attempt at one of the transitions

A successful attempt at one of the transitions (can you tell how pleased I am?)

Final Controller Setup

Here’s the layout I settled on for my MIDI controller:

• 4 buttons: Select software instrument tracks (e.g., piano, synth, etc.).

• 2 drum pads: Trigger next and previous scenes.

• 4 drum pads: For live percussion or triggering other sounds.

This setup strikes a balance between live playability and control without overcomplicating things.

My MIDI controller assignments

Next Steps: Practising for Muscle Memory

Now that the setup is functional, the focus shifts to practice. My goal is to internalise the flow of the performance:

• Repetition: Running through the song multiple times to cement when to play, trigger, or switch tracks.

• Breaking it down: Isolating tricky transitions to work on them in detail.

• Adapting: If something isn’t working consistently, I’ll simplify further to ensure I can stay present and engaged with the audience.

When performing live, my priority is connection and presence, so I don’t want to be distracted by technicalities. The more natural it feels in practice, the better the performance will be!

Setting Up Logic Pro Controller Assignments for My Live Performance

Today, I dedicated all my work time to setting up controller assignments for my MIDI controller, focusing on the live performance of "Vision In Purple." It’s been a deep dive into how to make my setup efficient and dynamic, but it’s definitely a learning curve. There are so many options when it comes to how I can configure everything, especially since I’m working with only 8 drum pads. Ideally, I would use something like a launchpad with many more pads to assign everything individually, but I’m figuring out how to make the most of my existing setup.

Ultimately, the goal is to get my MIDI controller to be dynamic—meaning that it will automatically play the correct instruments for each section of the song, which I believe will make live performance much smoother. So, I spent time researching and experimenting with different ways to set it all up in Logic Pro.

Selecting Different Instruments for Each Song Section

One of the first things I wanted to tackle was how to select different instruments without having to use the trackpad on my laptop during the live performance. In the past, I’ve manually selected the instrument I want to play using my laptop, but that’s not ideal when you’re on stage trying to focus on the performance.

After a lot of searching, I figured out a simple yet effective solution using Logic Pro's controller assignments. At first, I thought I might need third-party software to convert MIDI data to OSC (Open Sound Control) data, as some articles suggested. However, I discovered that Logic’s built-in ‘groups’ feature would do the trick.

Here’s how it works:

1. I can assign each instrument I want to play to a separate group in Logic.

2. Using Logic's controller assignments, I can select a parameter called ‘select members of group 1,’ for example, and assign it to a button on my MIDI controller. This will make the instrument playable without me needing to touch the laptop.

Alternatively, I found another option where you can assign controls to select the next or previous track, but I decided against that approach. It felt like it could be risky during a live performance—if I have to rely on knowing the exact order of tracks, it could throw me off mid-performance. The group method is more reliable and allows me to have each instrument assigned to a specific button on the controller for consistency.

Logic Pro Controller Assignments window with the parameter used for track selection

Triggering Scenes with My MIDI Controller

The next challenge was figuring out how to trigger different scenes during the live performance. The solution here is similar to how I manage instruments: I can assign controls to trigger the ‘previous’ and ‘next’ scenes, or I can assign specific controls to specific scenes.

Since I have a limited number of drum pads and buttons on my MIDI controller, I started thinking about how I can streamline this process. Here’s my idea: I could assign a single button to trigger the next scene and program it so that it also sets up the controller for the next section. For example, in the first verse, I might want to play piano, but when the chorus hits, I want to switch to a synthesizer sound. Instead of pressing multiple buttons to trigger the next scene and change the instrument, I could have a single button that triggers both actions.

This method would simplify the process during the performance, especially since I’m just starting with this style of live performance. Although it might reduce some flexibility for improvisation, I’m opting for simplicity at the beginning. I can always refine my approach and add more complexity as I become more comfortable with the system.

Challenges and Progress

At the moment, I haven’t yet figured out how to make the one-button scene and instrument reprogramming method work. I’ve run into a couple of issues with multiple parameters being assigned to a single button, but I’m confident that it’s possible. The progress has been slow, but I’m happy that I’ve gained a deeper understanding of Logic’s controller assignments window and how it works. This knowledge is helping me select different tracks more easily and efficiently.

I know this setup will be essential for my live performances, as it allows me to be more hands-free and focused on engaging with the audience. I still have a lot of testing and tweaking ahead, but I’m excited to see how it all comes together.