logic2ableton

Move a project between Logic Pro, Ableton Live, and Pro Tools. logic2ableton reads the DAWs' proprietary, undocumented session formats and rebuilds your project on the other side: audio placed on the timeline with clip trims intact, tempo, time signature, per-track colors, and note-accurate MIDI that lands as real MIDI tracks.

Wait — how is that possible? Logic stores its MIDI in an undocumented binary blob, and Pro Tools sessions are an obfuscated binary container with no public spec. So they got reverse-engineered — Logic's format verified against Apple's own shipping demo songs, and Pro Tools' against real studio sessions.

📖 Deep-dive: reverse-engineering Logic's binary format → 📖 Deep-dive: inside the Pro Tools session container →

It ships six production workflows in one repo, one desktop app, and one release train:

• logic2ableton — convert Logic Pro projects into Ableton Live sets
• ableton2logic — turn Ableton Live sets into Logic-ready transfer packages
• protools2ableton — convert Pro Tools sessions into Ableton Live sets
• protools2logic — turn Pro Tools sessions into Logic-ready transfer packages
• ableton2protools — turn Ableton Live sets into Pro Tools-ready transfer packages
• logic2protools — turn Logic Pro projects into Pro Tools-ready transfer packages

The product goal is speed with evidence: every run emits a report showing exactly what transferred cleanly, what needs manual cleanup, and where the source project exceeds what any cross-DAW workflow can preserve.

Why Use It

• One maintained project instead of separate one-off scripts for each DAW direction
• Desktop app for non-technical users, CLI for power users and automation
• Output built for real sessions: copied audio, timeline metadata, and explicit compatibility reporting
• Reports are first-class artifacts, not an afterthought

Workflow Matrix

What Works Well

Logic to Ableton

• Audio tracks into Ableton Arrangement View
• Region placement read from the Logic project itself: audio regions land where Logic had them, trimmed to the same slice of their file, on tracks named after the Logic tracks; older saves the decoder cannot read fall back to WAV BWF timestamps and Logic AIFF MARK chunks
• Tempo and time signature. Tempo changes are read from Logic's tempo track and become Live tempo automation; warped clips get a warp marker at each change, so the audio keeps its speed and its place (checked on a project with 85 tempo changes by opening the set in Live 12 and reading the tempo back)
• Overlap resolution for takes and comp bounces
• Audio membership follows the selected Logic alternative; unused and unreferenced takes are excluded
• Distinct per-track colors, with arrangement clips matching their track color
• MIDI regions decoded from Logic's binary project data land as native Ableton MIDI tracks inside the .als (and as Standard MIDI file exports): one clip per region at its arrangement position, and looped Logic regions become looping Live clips
• Logic markers become Live locators; muted regions are left out, as Logic would not play them
• --smpte-start sets the SMPTE time bar 1 plays at (or infers it with auto), for projects whose placement comes from audio timestamps
• --timeline supplies your own tempo map and/or markers in place of the ones read from the project; they become Live tempo automation, locators, and warp markers that follow the map (verified by opening the generated set in Live 12.4.3 and reading back its values)
• --keep-unwarped keeps matching tracks (sync tone, pilot tracks, timecode) as unwarped Live clips so they never stretch when the tempo changes
• Folder-saved Logic projects (a .logicx package next to a sibling Audio Files folder) are read the same as package-saved ones
• Multiple .logicx inputs in one run, converted and reported one after another
• The mixer: every track gets the level, pan and mute its channel strip has in the Logic project, audio and MIDI tracks alike. Where tracks play into a bus that an aux channel listens on (a drum bus, a summing stack), the aux becomes a Live group track with its level, pan and mute and those tracks inside it, so a bus fader still acts on the tracks that play through it. What the converter reads was compared with the pictures of its window that Logic saves inside each project: the mute buttons on the track headers and the levels, pans, bus and output assignments on the channel strips, more than 300 strips and headers in 23 project versions, after the six it was worked out on. They agree to within the 0.1 dB by which Logic rounds the levels it shows. Three converted sets opened in Live 12 showed the same level, pan, mute and group for all 76 of their tracks and groups. --mixer changes the values of the tracks named in a JSON file, and --no-mixer leaves every track at 0 dB, centred and unmuted
• --keep-outputs sends tracks that play to another output of the audio interface in Logic (3-4, 5-6, a mono output) to the same output in Live
• Plugin identification with VST3 suggestions in the report

Ableton to Logic

• Audio-track and clip discovery from .als
• MIDI-track and arrangement note extraction, exported as importable Standard MIDI files
• Tempo, locators, and a documented base time signature
• Logic-ready transfer package with:
  • Track Stems/ for the fastest arrangement-faithful import
  • Logic Timeline/Logic Timeline.mid for tempo and locator import
  • MIDI Tracks/ with one Standard MIDI file per Ableton MIDI track, notes placed at their arrangement positions
  • Audio Files/ grouped by Ableton track with timestamped WAV clip exports where supported
  • timeline_manifest.json
  • timeline_manifest.csv
  • locators.csv
  • IMPORT_TO_LOGIC.md
  • a saved transfer report

Pro Tools to Ableton / Logic

• Reads .ptx sessions directly (Pro Tools 10 through current .ptx saves, plus legacy .pts), including the XOR-obfuscated container
• Audio clips with their exact source trims (a clip that plays 8.6 s from the middle of a take stays that clip), placed at their session positions
• Stereo tracks reassembled from Pro Tools' per-channel lanes
• MIDI notes decoded from the session and created as native Ableton MIDI tracks or Logic-importable MIDI files
• Session sample rate and format version detection
• Crossfade render files are recognized and skipped so they don't appear as phantom clips

Ableton / Logic to Pro Tools

• Pro Tools import package with per-track folders of timestamped WAV clip exports
• BWF TimeReference stamped for Pro Tools' Spot > Original Time Stamp workflow (session start 00:00:00:00, no SMPTE hour offset)
• One Standard MIDI file per MIDI track
• manifest.json, a transfer report, and a step-by-step IMPORT GUIDE.txt

Current Limits

Logic to Ableton

• MIDI notes transfer as native MIDI tracks (and .mid exports), but the software instruments, their settings, and MIDI effects are not recreated — reload instruments in Ableton
• Region placement, loops, track names and markers come from the project's own arrangement data. That decoding was worked out on Logic 10.6 and Logic 11 saves and has since decoded all 246 saved versions of 117 projects without falling back (their latest saves come from Logic 10.2, 11.1, 11.2, 12.2 and 12.3; only the mixer part of those was compared with Logic). The report says "Region positions: read from the Logic arrangement" when it applies. Saves it cannot read fall back to audio timestamps, MIDI 1, MIDI 2, ... track names, and a warning
• Regions that start before bar 1 are moved to bar 1 (audio is trimmed by the same amount) because a Live arrangement cannot start earlier
• Looped audio regions are written as repeated clips; the report lists every region it unrolled
• Logic tracks that share a name are kept apart by numbering the later ones (Guitar, Guitar (2)), and the report says which were renamed
• A Live track plays one clip at a time. Where audio regions overlap on one Logic track, the later region is kept whole and the earlier one is cut around it; overlapping MIDI regions become one clip holding all their notes. The report lists each case. No real project with overlapping regions has been checked yet, so compare those spots with Logic
• Region fades, crossfades and region gain are not transferred, so edit points are plain cuts in Live. Take folders are untested; flatten them in Logic first
• Tempo changes are read as steps, which is how the projects seen so far store them. Logic also stores the time each change falls on; if the steps do not add up to those times (a tempo curve, for example) the report says so. The Live set starts at bar 1, so a different tempo before bar 1 (a count-in, say) only decides how much of the audio that starts there is trimmed. Tempos outside Live's 20 to 999 BPM range are limited to it
• When the arrangement cannot be read and placement falls back to audio timestamps, Logic's tempo changes are reported but not applied; supply them with --timeline
• --smpte-start only matters for the timestamp fallback; it must then match the project's own synchronization setting (default 01:00:00:00), and the report lists any files placed at bar 1 because their timestamp precedes it
• Automation is not recreated
• Mixer values are the ones the project was saved with. Fader and pan automation is not read, so a track with volume automation gets the level its fader had when the project was saved. Solo is not carried over: when a project was saved with a solo on, the tracks that solo silenced play in Live, and the report names them and the soloed tracks. Levels were compared with what Logic shows between +2.9 and -27.1 dB. Below 0 dB Logic shows a level that sits between two of its 0.1 dB steps as the lower one, so such a fader reads 0.1 dB lower there than in the report (-6.0 in Logic, -5.9 here). Live shows pan as 50L to 50R where Logic counts -64 to +63
• Sends are not recreated, and neither are aux channels fed only by sends (reverb and delay returns), nor anything in an insert slot. A bus that no aux channel listens on, or that several do, is left ungrouped and the report says so. The faders of Logic's output channels and its master fader are not applied, nor are the level and mute of a folder stack or a VCA fader, and a track muted in Logic's CPU-saving mute mode may not be seen as muted. A group is named after its aux channel, which is not always the name the stack shows in Logic
• Tracks play to Live's main output unless --keep-outputs is given. With it, a track whose output the current audio device does not have shows no output channel in Live and stays silent until you choose one
• Plugin parameters are not recreated
• In the timestamp fallback, imported audio without embedded timestamps defaults to bar 1
• Media outside Media/Audio Files is not copied automatically
• WAV duration detection includes IEEE float recordings. Sources whose duration cannot be read are skipped with a report warning

Ableton to Logic

• The reverse lane does not synthesize a native .logicx package
• MIDI note data transfers, but instruments, devices, racks, MIDI effects, and plugin state do not — reload those in Logic
• Looping MIDI clips are unrolled to their arrangement length, honoring the loop brace and start marker the way Live plays them (verified against Live 12.4's own Consolidate output); notes cut at a loop or clip boundary are shortened, not extended
• Ableton devices, racks, plugin state, and return-bus processing are not transferred
• Warped clips are exported with best-effort timing, but they still need review inside Logic before delivery
• The base tempo, meter, and markers are exported into the Logic Timeline MIDI file. Later tempo and meter changes are reported but are not reconstructed
• Non-PCM sources that cannot be rendered to timestamped WAV in-process are copied as references and flagged in the report/manifest
• Media references outside the Ableton project folder are blocked. Use Live's Collect All and Save before transferring a set that relies on external files
• PCM and float audio are rendered in chunks. Individual rendered WAVs are limited to the RIFF format's 4 GiB size limit
• The transfer package covers audio and MIDI; use the stems and MIDI files first, then clip exports and the manifest if you need finer reconstruction

Pro Tools lanes

• Session tempo is not recoverable from .ptx yet. Audio positions are sample-exact regardless, but beat positions are computed at an assumed tempo (default 120 BPM, override with --tempo). Keep the destination set at that tempo, or pass the real session BPM
• Plugins, inserts, sends, automation, clip gain, and fades are not transferred; crossfade renders are skipped
• Elastic Audio state is not reconstructed; clips reference their source audio directly
• The source session's Audio Files/ folder must sit next to the .ptx for media to be copied
• MIDI regions anchor to their first note (a leading-silence offset inside a region is not preserved)

If a project lands imperfectly, the first thing to inspect is the generated report. It is the primary support artifact for this project.

Reverse Import Strategy

For ableton2logic, the cleanest path is:

1. Import Logic Timeline/Logic Timeline.mid into a new empty Logic project at the project start.
2. Drag every file from Track Stems/ into Logic starting at bar 1.
3. If you need clip-level editing, import Audio Files/ and use Logic's Edit > Move > To Recorded Position command on timestamped WAV clips.
4. Use the transfer report and timeline_manifest.csv to review warped clips, copied-source files, and any manual cleanup.

Install

Desktop App

Download the latest installer or portable build from GitHub Releases:

• Windows: NSIS installer and portable .exe
• macOS: Apple Silicon .dmg, plus a second Apple Silicon .dmg (filename ending -arm64-macos11.dmg) for macOS 11 Big Sur

Notes:

• macOS builds are ad-hoc signed but not notarized, so Gatekeeper quarantines them on first download. If macOS says the app "is damaged and can't be opened," clear the quarantine flag once after copying it to Applications:

  xattr -dr com.apple.quarantine "/Applications/Logic Ableton Transfer.app"
  

  Alternatively, right-click the app and choose Open, then confirm in the dialog.

• Intel macOS users currently need a self-hosted packaging flow or a local source build (release DMGs are Apple Silicon only).

• The regular macOS DMG needs macOS 12 or newer. The macOS 11 DMG is built against Electron 37.10.3 instead of the current Electron release, because current Electron requires macOS 12+. Electron 37 has been end-of-life since 2026-01-13 and gets no further security updates, so use the regular DMG unless you're actually still on Big Sur.

• The desktop app bundles the converter binary, so end users do not need Python installed.

Install from PyPI

pip install logic2ableton

If you prefer an isolated global CLI install:

pipx install logic2ableton

Then run from anywhere:

logic2ableton "path/to/MySong.logicx" --output ./output

Show the installed version:

logic2ableton --version

Quick Start

Desktop Workflow

1. Launch the app.
2. Drop any session file — .logicx, .als, or .ptx — into the window; the app detects the source DAW.
3. Pick the destination DAW and review the preview.
4. Select an output directory, run the transfer, and inspect the report if anything looks off.

CLI Workflow

Choose the command that matches the route:

Logic to Ableton:

logic2ableton "/path/to/MySong.logicx" --output ./output

Logic to Ableton for a SMPTE-synced live show: infer the timecode hour, keep the sync and pilot tracks from stretching, and apply a tempo map with markers:

logic2ableton "Song.logicx" --output ./out --smpte-start auto --keep-unwarped "LTC*" --keep-unwarped "Pilot*" --timeline timeline.json

Batch convert several Logic projects in one run:

logic2ableton "Song1.logicx" "Song2.logicx" "Song3.logicx" --output ./output

Ableton to Logic:

ableton2logic "/path/to/MySet.als" --output ./output

Pro Tools to Ableton (pass the session tempo so beat positions line up):

protools2ableton "/path/to/MySession.ptx" --output ./output --tempo 128

Pro Tools to Logic:

protools2logic "/path/to/MySession.ptx" --output ./output --tempo 128

Ableton or Logic to Pro Tools:

ableton2protools "/path/to/MySet.als" --output ./output
logic2protools "/path/to/MySong.logicx" --output ./output

Fastest Logic import after the package is created:

1. Open IMPORT_TO_LOGIC.md.
2. Import Logic Timeline/Logic Timeline.mid into an empty Logic project at the timeline start.
3. Drag Track Stems/*.wav into Logic starting at bar 1.
4. Use Audio Files/ only when you want clip-level reconstruction instead of full-track stems.

The original logic2ableton command also auto-detects .als and .ptx input:

logic2ableton "/path/to/MySet.als" --output ./output      # runs ableton2logic
logic2ableton "/path/to/MySession.ptx" --output ./output  # runs protools2ableton

Preview-only / report-only:

logic2ableton "/path/to/MySong.logicx" --report-only
ableton2logic "/path/to/MySet.als" --report-only

Write the mixer read from a Logic project to a JSON file you can edit:

logic2ableton "/path/to/MySong.logicx" --output ./output --generate-mixer-template --report-only

Convert with the values that file gives; tracks and fields it leaves out keep what Logic has:

logic2ableton "/path/to/MySong.logicx" --output ./output --mixer ./output/mixer_overrides.json

Keep the interface outputs of a playback rig, so a click on outputs 11-12 in Logic is on Ext. Out 11/12 in Live:

logic2ableton "/path/to/MySong.logicx" --output ./output --keep-outputs

Emit JSON progress for app or automation integration:

logic2ableton "/path/to/MySong.logicx" --output ./output --json-progress
ableton2logic "/path/to/MySet.als" --output ./output --json-progress

Progress events report audio counts (tracks, clips, audio_files) separately from midi_tracks and midi_notes. Previews include recovered MIDI content. For Ableton output, the completion event's midi_tracks counts native tracks in the set; midi_files separately counts exported .mid sidecars.

A failed run ends with an error event whose failure_stage names the step that failed (for example timeline, parsing or generating) and whose error holds the reason. The saved report keeps any analysis already done and ends with the same stage and reason.

Pro Tools previews check referenced audio on disk. The report lists found, missing, and skipped sources, and compatibility_warnings names missing media before conversion begins. These notes also appear in the desktop preview.

CLI Options

Every lane's input argument accepts one or more paths. Pass several to convert each in turn; the CLI prints a per-file progress line and a converted/failed summary at the end.

Shared

Logic to Ableton Only

Timeline JSON

Tempo changes and markers are read from the Logic project. --timeline is for supplying your own: tempo entries in the file replace the project's tempo changes, and markers in the file replace the project's markers. Whatever the file leaves out is still taken from the project:

{
  "tempo": [{"bar": 9, "bpm": 132}],
  "markers": [{"bar": 9, "name": "Chorus"}]
}

Each tempo or markers entry needs a position: either a 1-based bar with an optional 1-based beat (defaults to 1), or an absolute beats value counted in quarter notes from bar 1 (so bar 1 is 0). Give one or the other, not both. Bar and beat positions are resolved against the Logic project's own base time signature. Tempo changes are steps, not ramps: each breakpoint holds its BPM until the next one, and the report's TIMELINE section, the Live tempo automation, and the clip warp markers all follow that same map.

Pro Tools Imports Only

Output Layout

Each conversion creates a fresh project or transfer folder. If the name already exists, the new folder gets a suffix such as (2), preserving the earlier export. Project and track names are made safe for filenames on Windows and macOS.

Logic (or Pro Tools) to Ableton

output/
  MySong Project/
    MySong.als            <- audio tracks + native MIDI tracks
    Samples/
      Imported/
        *.wav / *.aif / *.aiff / *.mp3 / *.m4a
    MIDI/
      01 - MIDI 1.mid
  MySong_conversion_report.txt

Ableton to Logic

output/
  MySet Logic Transfer/
    Track Stems/
      01 - Drums.wav
      02 - Vocals.wav
    Logic Timeline/
      Logic Timeline.mid
    MIDI Tracks/
      01 - Bass.mid
      02 - Lead.mid
    Audio Files/
      01 - Drums/
      02 - Vocals/
    timeline_manifest.json
    timeline_manifest.csv
    locators.csv
    IMPORT_TO_LOGIC.md
    MySet_logic_transfer_report.txt

Ableton (or Logic) to Pro Tools

output/
  MySet Pro Tools Transfer/
    Audio Files/
      01 - Drums/
        001 - Kick Loop - *.wav   <- BWF TimeReference stamped for Spot > Original Time Stamp
      02 - Vocals/
    MIDI/
      01 - Bass.mid
    manifest.json
    IMPORT GUIDE.txt
    MySet_protools_transfer_report.txt
  MySet_protools_transfer_report.txt

What "Production Ready" Means Here

• Repeated validation across parser tests, package builds, standalone converter builds, and desktop packaging
• Windows desktop smoke coverage in CI before tagged release packaging
• Reports emitted on both success and failure paths so support starts with evidence instead of guesswork
• Desktop app safety rails around approved files, active jobs, and artifact opening
• Ableton to Logic now ships multiple reconstruction layers instead of a single manifest-only package
• The Pro Tools parser is validated against a real Pro Tools 2023 studio session (96 kHz, comped vocals, stereo lanes) and a synthetic obfuscated fixture that runs in CI
• All six conversion lanes ship from the same repo and version together

Reading The Reports

Every Logic to Ableton report opens with the SMPTE start it used (the default 01:00:00:00, a value passed with --smpte-start, or one inferred from the earliest recording) and whether it found the project's audio in a package or a folder-style layout.

Pay close attention to COMPATIBILITY WARNINGS.

Typical warnings include:

• Audio referenced by the source project but missing on disk
• Logic audio with no embedded timeline timestamp
• Audio files that start before the SMPTE start value; these land at bar 1 instead of their real position, and the report names each one
• Ableton clips that rely on warping or other live processing that cannot be rendered faithfully by this project
• Reverse-lane sources that were copied as references instead of rendered into timestamped WAV files

Warnings generally mean one of two things:

• the converter needs a parser/generator improvement
• the source session needs manual cleanup or a more deliberate export/import path

Development

The reverse-engineering write-ups in docs/ explain how the Logic MIDI and Pro Tools session formats were decoded and what is still open.

Run tests:

python -m pytest tests -q
ruff check logic2ableton tests scripts

Tests against real sessions are optional and skipped by default. To run them, point L2A_LOGIC_FIXTURE at a local .logicx package and L2A_PTX_FIXTURE at a local .ptx file before invoking pytest.

Run the six-lane smoke check, which synthesizes a Logic project, a Live set, and a Pro Tools session and converts each through the CLI:

python -m scripts.smoke_standalone --source
python -m scripts.smoke_standalone dist/logic2ableton.exe   # against the packaged binary

No third-party Python dependencies. The Ableton template is bundled, so no Ableton installation is needed to generate Live sets.

Build the Python package:

python -m build

Build the standalone converter:

pyinstaller logic2ableton.spec
dist/logic2ableton.exe --version

Run the desktop app in development:

cd app
npm ci
npm run dev

Build the desktop app:

cd app
npm ci
npm run build
npm run typecheck
npm test

The desktop bundles Geist Sans directly; its font license is included in app/src/renderer/public/Geist-LICENSE.txt and copied into the built app.

Build the Windows release artifacts locally:

pyinstaller logic2ableton.spec
copy dist\logic2ableton.exe app\resources\logic2ableton.exe
cd app
npm ci
npm run dist:win

Release Process

GitHub Actions validates:

• Ruff lint and the desktop app build
• Python tests on Windows and macOS
• Python package builds
• A packaged-binary smoke run through all six conversion lanes
• Tagged release packaging for Windows and macOS

Publishing a release is done by pushing a v* tag. The workflow uploads the generated installers to GitHub Releases automatically. The same workflow publishes the Python package to PyPI through a trusted publisher (environment pypi) once the repository variable PYPI_PUBLISH is set to true.

The macOS build matrix produces two Apple Silicon DMGs: the regular one (macOS 12+) and a second built against Electron 37.10.3 for macOS 11 Big Sur. The installer job can also be run on demand with workflow_dispatch, which builds and uploads the same artifacts without cutting a GitHub Release.

Bug Reports

Useful issues include:

• The Logic Pro or Ableton Live version used to save the project
• The exact generated report
• A minimal failing project if one can be shared
• Whether the issue is in the desktop app, CLI, or packaging

Open issues here: https://github.com/Evilander/logic2ableton/issues

License

MIT