Getting Started with the Ableton Extension SDK

Ableton recently released the Extension SDK — a new way to build tools that interact directly with your Live Set using JavaScript and Node.js. Extensions live in Live’s right-click context menu and can manipulate tracks, clips, MIDI notes, devices, tempo, and more. Here’s what you need to know to get started.

What Are Extensions?

Extensions are small Node.js programs that run inside Live 12 Suite (Beta, version 12.4.5 or later). They are triggered from the context menu when you right-click on tracks, clips, or other items in your Set. After selecting an Extension, a pop-up appears where you can adjust parameters before running it. The Extension executes once, performs its task, and stops.

Unlike Max for Live — which is a deep patching environment for synthesis and custom instruments — Extensions are about workflow and structure: manipulating your arrangement, analyzing audio, generating MIDI, or connecting to external services.

What You Can Build

The SDK opens up a wide range of possibilities:

• Transform MIDI: Remap notes, generate chords, create arpeggiation patterns
• Analyze audio: Detect silence, transients, pitch, or spectral content
• Automate repetitive tasks: Batch-rename tracks, reorder clips, normalize gain
• Generate patterns: Algorithmic drum fills, evolving melodies, probabilistic sequences
• Process audio clips: For example, BBenCut applies the BBCut breakbeat cutting algorithms to AudioClips in the Arrangement View
• Connect to external services: Fetch chord progressions or lyrics from an API
• Even play games: The SDK is flexible enough that someone built a game inside Live

Requirements

To develop Extensions, you need:

• Live 12 Suite Beta, version 12.4.5 or later (not available in Standard, Intro, or Lite)
• Node.js v24.16.0 (LTS)
• The Ableton Extensions SDK package (@ableton-extensions/sdk)

Project Structure

An Extension is a standard Node.js/TypeScript project with a manifest.json:

1
2
3
4
5
6
7

{
    "name": "Strip Silence",
    "author": "Ableton",
    "entry": "dist/extension.js",
    "version": "0.0.1",
    "minimumApiVersion": "1.0.0"
}

The entry field points to your compiled JavaScript. The minimumApiVersion ensures compatibility with the SDK runtime inside Live. You write your code in TypeScript and compile it before loading it into Live via Settings → Extensions.

A Simple Extension: Context Menu Action

Here’s the minimal example — registering a command that runs when you right-click a clip slot:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

import { initialize, type ActivationContext } from "@ableton-extensions/sdk";

export function activate(context: ActivationContext) {
  const api = initialize(context, "1.0.0");

  api.commands.registerCommand("myClipSlotAction", () => {
    console.log("You right-clicked on a ClipSlot!");
  });

  api.ui.registerContextMenuAction(
    "ClipSlot",
    "Process this ClipSlot",
    "myClipSlotAction",
  );
}

The key pattern: registerContextMenuAction tells Live where the Extension appears (on which item type), and registerCommand defines what happens when it’s selected. The item types include ClipSlot, MidiTrack.ArrangementSelection, AudioTrack.ArrangementSelection, and others — each specifying which right-click context triggers your extension.

Working with Arrangement Selections

A more useful Extension reacts to the user’s selection in the Arrangement View. The SDK provides the selection’s time range and selected tracks:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

import {
  initialize, Track, MidiTrack, DataModelObject, TakeLane,
  type ActivationContext, type ArrangementSelection,
} from "@ableton-extensions/sdk";

export function activate(activation: ActivationContext) {
  const api = initialize(activation, "1.0.0");

  api.ui.registerContextMenuAction(
    "MidiTrack.ArrangementSelection",
    "Process selection",
    "myExtension.processSelection",
  );

  api.commands.registerCommand(
    "myExtension.processSelection",
    async (arg: unknown) => {
      const selection = arg as ArrangementSelection;

      const selectedObjects = selection.selected_lanes.map((handle) =>
        api.getObjectFromHandle(handle, DataModelObject),
      );

      const midiLanes = selectedObjects.filter(
        (obj): obj is MidiTrack<"1.0.0"> | TakeLane<"1.0.0"> =>
          obj instanceof MidiTrack ||
          (obj instanceof TakeLane && obj.parent instanceof MidiTrack),
      );

      if (midiLanes.length > 0) {
        const newClips = await Promise.all(
          midiLanes.map((lane) =>
            lane.createMidiClip(
              selection.time_selection_start,
              selection.time_selection_end - selection.time_selection_start,
            ),
          ),
        );
        newClips.forEach((clip, i) => {
          clip.name = `New Clip ${i + 1}`;
        });
      }
    },
  );
}

This Extension creates a new MIDI clip on every selected MIDI track or take lane, spanning the user’s time selection. The selection.selected_lanes array gives you handles to the tracks, and time_selection_start / time_selection_end provide beat-time boundaries.

Audio Analysis: The Strip Silence Extension

One of the official examples is Strip Silence — it analyzes the audio on selected tracks, detects silent regions, and removes them. Here’s the core analysis logic:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

function computeSilenceRanges(
  channels: Float32Array[],
  opts: SilenceOptions,
): SilenceRange[] {
  const { sampleRate, windowSize, rmsThreshold, minSilenceDuration } = opts;
  const windowDur = windowSize / sampleRate;
  const minWindows = Math.ceil(minSilenceDuration / windowDur);

  // Compute RMS for each window
  const rmsVals: number[] = [];
  for (let i = 0; i < channels[0]!.length; i += windowSize) {
    const end = Math.min(i + windowSize, channels[0]!.length);
    let sumSq = 0, count = 0;
    for (let j = i; j < end; j++) {
      for (let c = 0; c < channels.length; c++) {
        const v = channels[c]![j]!;
        sumSq += v * v;
      }
      count += channels.length;
    }
    rmsVals.push(Math.sqrt(sumSq / count));
  }

  // Mark windows below threshold as silent
  const silentFlags = rmsVals.map((v) => v < rmsThreshold);

  // Find contiguous silent regions meeting minimum duration
  const ranges: SilenceRange[] = [];
  let runStart = -1;
  for (let i = 0; i < silentFlags.length; i++) {
    if (silentFlags[i]) {
      if (runStart === -1) runStart = i;
    } else if (runStart !== -1) {
      const runLen = i - runStart;
      if (runLen >= minWindows) {
        ranges.push({ start: runStart * windowDur, end: i * windowDur });
      }
      runStart = -1;
    }
  }
  // ... handle final run, merge adjacent ranges
  return ranges;
}

The Extension renders the pre-FX audio of each selected track to a temporary WAV file, decodes it into float samples, computes RMS values in sliding windows, and identifies regions below a configurable threshold. Then it removes those regions in a single transaction:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

const promises = context.withinTransaction(() => {
  return results.flatMap(({ track, silence }) =>
    silence.map((r) => {
      const start = selection.time_selection_start + r.start / beatsPerSecond;
      const end = selection.time_selection_start + r.end / beatsPerSecond;
      return track.clearClipsInRange(start, end);
    }),
  );
});
await Promise.all(promises);

The withinTransaction call wraps all clip deletions into one undo step — a clean pattern for batch operations that should be atomic.

Progress Dialogs and UI

Long-running operations can show a progress dialog using the built-in UI helpers:

1
2
3
4
5
6
7

await context.ui.withinProgressDialog("Strip Silence", {}, async (update, abortSignal) => {
  for (let i = 0; i < tracks.length; i++) {
    if (abortSignal.aborted) return;
    update(`Analyzing track ${i + 1}/${tracks.length}: ${track.name}`, (i / tracks.length) * 50);
    // ... do work
  }
});

The abortSignal lets users cancel the operation, and update() provides both a status message and a percentage.

Extensions vs. Max for Live

They complement each other: Max for Live handles the audio signal path and real-time DSP, while Extensions handle the arrangement, metadata, and structural manipulation.

Getting Started

1. Install Node.js v24.16.0
2. Create a new Extension project with npm init, add @ableton-extensions/sdk as a dependency
3. Write a manifest.json and your extension code in src/extension.ts
4. Compile with TypeScript (tsc or a bundler)
5. Load it in Live via Settings → Extensions → Install Extension

The SDK comes with several example Extensions — Strip Silence, Arrangement Selection, Context Menu, Progress Dialog, Modal Dialog, Audio Clips, and Warp Mode — each demonstrating a different aspect of the API. The full API documentation covers all available classes and functions in detail.

AI-Assisted Development

The SDK is built on standard web technologies that AI coding assistants handle well. The official FAQ even mentions that “if you can clearly describe your idea for an Extension, you may be able to build a working Extension with AI assistance, without any coding experience.” The Strip Silence example was reportedly written with Copilot — showing that the API is approachable enough for AI tools to generate functional code.