Praat AudioTools: Max/MSP External + Bidirectional Ableton Live (M4L) Integration

What this does

This integration layer gives Praat AudioTools two complementary host connections:

1. Max/MSP external
   A dedicated AudioTools.praat~ external allows Max users to run Praat AudioTools processing from inside Max. The Windows package contains AudioTools.praat~.mxe64; a corresponding macOS build is also supported and tested. Audio can move from buffer~ into Praat, be processed by a Praat script, and return to Max. The external also supports MC workflows.
2. Ableton Live via Max for Live
   The AudioTools Live Bridge provides a bidirectional file-based connection. Praat can send a processed Sound to the Ableton Arrangement at the current playhead position, while a selected Ableton Audio Clip can be opened directly in Praat from the M4L device.

System overview

The system contains two related but independent host integrations. The Ableton integration itself is now bidirectional.

In the Max path, the external manages script-driven transfer and processing. In the Praat-to-Ableton path, Praat exports the selected processed Sound and sends its path to the M4L bridge; the bridge reads Live's current song time and creates the audio clip at that exact timeline position. In the reverse direction, the M4L device reads the source-file path of the currently selected audio clip and asks Praat to open that file directly.

Max/MSP connection

Overview

The Max/MSP integration is implemented as the dedicated AudioTools.praat~ external. In the Windows package the binary is AudioTools.praat~.mxe64; the system also has a working macOS build. The external makes Praat AudioTools available as a Max-hosted processing component while Praat performs the actual script execution and offline or semi-offline sound transformation.

Package integration

The Max package includes the external together with its help/reference material, JavaScript support files, example content, and a Praat AudioTools installation tree. This makes the connection a packaged Max environment rather than a loose collection of scripts.

What the Max connection enables

• Script execution from Max: A patch can call Praat AudioTools scripts as part of a larger Max system.
• Buffer-to-buffer processing: A source buffer~ can be transferred to Praat and the processed result loaded into a destination buffer~.
• Praat as backend: The user can remain in Max while Praat performs the analysis or transformation stage.
• MC workflows: Multichannel and parallel structures can be built around Praat processing inside Max.
• Cross-platform use: The external workflow is available on both Windows and macOS.

Ableton Live / M4L connection

Overview

The Ableton integration uses the AudioTools Live Bridge Max for Live device. AudioTools.LiveBridge.js handles Live API communication, while a Node for Max helper opens selected Live audio files in Praat. The device therefore supports both Praat → Ableton and Ableton → Praat workflows.

Precise timeline placement

The bridge uses the Live API rather than guessing the timeline location. AudioTools.LiveBridge.js binds to the Live Song and Track objects, reads current_song_time, and calls create_audio_clip(path, position). This is why the returned Praat result appears exactly where the Ableton playhead is positioned.

Communication

The M4L side listens with udpreceive 7474 @defer 1. The message carries an absolute audio-file path, for example through the import, sendtolive, or output audio message forms understood by the bridge. Audio itself is not transmitted over UDP.

Open selected Ableton clip in Praat

Bridge files and cleanup

Send_to_Ableton.praat writes uniquely named WAV files to the AudioTools Ableton bridge folder. A separate Clean_Ableton_Bridge.praat utility lets the user decide when those WAV files and Ableton .asd sidecars should be removed.

Typical workflows

Workflow 1: Max buffer processing

Use case: experimental patch-based sound design

1. Load or record audio into a Max buffer~
2. Route the buffer through AudioTools.praat~
3. Run a selected Praat AudioTools script
4. Return the processed result to a destination buffer~
5. Continue routing, sequencing, or layering in Max

Result: Praat becomes a script-driven sound-processing module inside Max/MSP.

Workflow 2: Max script-driven transformation chain

Use case: algorithmic or interactive systems

1. Use Max for timing, logic, UI, routing, or sensor/control input
2. Trigger Praat scripts at selected points in the patch
3. Use Praat for analysis, transformation, or resynthesis
4. Return results to Max for additional processing or playback

Result: Max handles interactive system logic while Praat contributes specialised analysis and transformation.

Workflow 3: Praat result to Ableton playhead

Use case: DAW-centered composition and iterative sound design

1. Process or generate audio in Praat AudioTools
2. Select the resulting Sound
3. Place the Ableton playhead at the desired Arrangement position
4. Run Send_to_Ableton.praat
5. The M4L bridge inserts the file on the target track at the current song time

Result: A Praat result can be auditioned and arranged in Live without manually exporting, browsing for, and dragging the file onto the timeline.

Workflow 4: Open a selected Ableton clip in Praat

Use case: rapid return from DAW context to Praat analysis or transformation

1. Select an Audio Clip in Ableton Live
2. Click OPEN IN PRAAT in the M4L device
3. The bridge reads the selected clip's source-file path
4. Praat opens the referenced audio file as a Sound
5. Continue analysis or transformation in Praat

Result: The user can move from the Live Arrangement directly to Praat without manually locating the clip's source file in the file system.

Workflow 5: Iterative Praat ↔ Ableton composition

Use case: recursive composition

1. Open an Ableton source clip directly in Praat
2. Analyze, generate, or transform material in Praat
3. Send the resulting Sound back to Ableton at the current playhead
4. Evaluate and arrange the result in musical context
5. Repeat as needed

Result: Praat and Ableton form a practical bidirectional composition loop while retaining their distinct roles.

Key features

• Dedicated AudioTools.praat~ external for Max/MSP
• Working Max external builds for Windows and macOS
• Execution of Praat AudioTools scripts from Max patches
• Audio transfer from buffer~ to Praat and back
• Support for MC workflows in Max
• Bidirectional AudioTools Max for Live bridge for Ableton Live
• Direct insertion of processed Praat audio at the current Ableton Arrangement playhead
• Live API placement using current_song_time and create_audio_clip
• Direct Praat-to-Ableton sending via Send_to_Ableton.praat
• OPEN IN PRAAT command for the currently selected Ableton Audio Clip
• Live API source-file resolution through detail_clip and file_path
• Direct Praat launch/open through an embedded Node for Max helper; no Python required
• Frozen M4L distribution can operate without installing the Praat AudioTools Max package or AudioTools.praat~
• Separate bridge-file cleanup via Clean_Ableton_Bridge.praat
• Clear separation between the processing engine (Praat) and host control/timeline environments (Max and Live)

Technical implementation

Max/MSP external

The Max connection is centered on AudioTools.praat~. The package contains the compiled external, help/reference files, JavaScript support modules, example material, and the Praat AudioTools resources used by the integration.

1. Max receives or references audio in buffer~
2. the external prepares the material for Praat
3. Praat executes the requested AudioTools script
4. the result is returned to Max
5. the destination buffer or downstream Max patch continues the workflow

This turns Praat into a scriptable backend processor controlled from Max rather than a conventional sample-by-sample MSP effect.

Praat → Ableton Live

The M4L bridge uses AudioTools.LiveBridge.js and listens on UDP port 7474. The JavaScript receives the absolute path of a processed audio file and performs the timeline insertion through Ableton's Live API.

1. live.path resolves the current Live Song and target Track
2. their IDs are bound to LiveAPI objects
3. the bridge receives an audio path from Praat
4. current_song_time provides the exact insertion position
5. create_audio_clip(path, position) creates the Arrangement clip
6. the bridge verifies that the number of Arrangement clips increased

Ableton Live → Praat

For OPEN IN PRAAT, the same Live bridge resolves live_set view detail_clip, binds the selected clip by its canonical Live API ID, checks is_audio_clip, and reads file_path. The path is passed to an embedded Node for Max helper, which locates Praat and starts it with the explicit --open option.

1. the user selects an Audio Clip in Live
2. the M4L bridge resolves the current detail_clip
3. file_path supplies the referenced source-audio path
4. Node for Max locates the Praat executable/application
5. Praat --open <source-file> opens the file in the Praat Objects window

Praat-to-Live sender

Send_to_Ableton.praat exports the selected Sound to a uniquely named WAV in the AudioTools bridge directory and sends the file path to the M4L listener. The sender does not require Python. Cleanup is intentionally separated into Clean_Ableton_Bridge.praat, so the user decides when referenced media can safely be removed.

Architectural principle

The integrations share one principle but serve different host roles:

• Praat remains the analysis, scripting, transformation, and resynthesis engine
• Max/MSP provides patch-based control, buffer exchange, routing, and MC structures
• Ableton Live provides arrangement, sequencing, clip selection, and exact timeline placement
• M4L provides the bidirectional Live API bridge between Ableton clips and Praat-accessible audio files

Installation and distribution

Max/MSP external workflow

Using the dedicated Max/MSP integration requires the Praat AudioTools Max package with the platform-specific AudioTools.praat~ external and its associated resources.

Standalone M4L workflow

A frozen AudioTools Max for Live device can embed its JavaScript and Node for Max dependencies. For the M4L bridge itself, the end user therefore does not need to install the Praat AudioTools Max package, AudioTools.praat~, or Python.

Praat location

The embedded Node helper searches automatically for Praat in common locations and can also use the system PATH or a PRAAT_PATH environment variable.

If the full Praat AudioTools Max package is installed, the helper can also use the Praat copy included with that package. This is a fallback, not a requirement for the standalone M4L distribution.

Applications

• Experimental sound design: Use Praat processing as a transformation stage inside a Max patch.
• Interactive patch systems: Trigger Praat scripts from Max according to algorithmic logic, controls, or live input.
• DAW-based composition: Send a processed Praat Sound directly to the desired Ableton Arrangement position.
• Rapid DAW-to-analysis workflow: Open the source file of a selected Ableton Audio Clip directly in Praat.
• Iterative composition: Move repeatedly between Ableton context and Praat transformation without manual file browsing.
• Research and prototyping: Combine Praat analysis with Max control structures and DAW-based comparison or auditioning.
• Multichannel processes: Build MC-compatible Max structures around Praat AudioTools processing.
• Hybrid composition practice: Combine Praat's scriptable transformations, Max's modular control, and Ableton's timeline environment.