Skip to content
Skills Library
Other · Building & coding

arrange-render

/arrange-render

Render, mix and export an approved ARRANGE plan. Runs the plan's instrument layers with ACE-Step 1.5 (Lego, one layer at a time on the context the plan declares), records every candidate on the plan, measures each one against the piano (chroma, level, vocal pitch), makes a listening preview, polishes the sung voice over the piano into a finished mix (vocal chain, voice in front, -14 LUFS), and exports zero-aligned full-length stems plus a tempo-map and marker MIDI file and import notes for Logic Pro. Use when someone wants to render or re-render a planned layer, hear the plan with its candidat

Repository
arrange ↗
Licence
Apache-2.0
Last repository change
06.11.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
16
Scripts
9
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 06.11.2026, without references to retired models or APIs.

Licence

Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.

What to check before installing
  • 9 scripts in this package. Review them before installing, as Claude may execute them.

Scripts: scripts/backends/ace_step.py, scripts/backends/soulx.py, scripts/export.py, scripts/mix.py, scripts/polish.py, scripts/register.py, scripts/smf.py, scripts/stub.py, scripts/verify.py

What it does and when to use it

Render, mix and export an approved ARRANGE plan. Runs the plan's instrument layers with ACE-Step 1.5 (Lego, one layer at a time on the context the plan declares), records every candidate on the plan, measures each one against the piano (chroma, level, vocal pitch), makes a listening preview, polishes the sung voice over the piano into a finished mix (vocal chain, voice in front, -14 LUFS), and exports zero-aligned full-length stems plus a tempo-map and marker MIDI file and import notes for Logic Pro. Use when someone wants to render or re-render a planned layer, hear the plan with its candidat

Original author description

Render, mix and export an approved ARRANGE plan. Runs the plan's instrument layers with ACE-Step 1.5 (Lego, one layer at a time on the context the plan declares), records every candidate on the plan, measures each one against the piano (chroma, level, vocal pitch), makes a listening preview, polishes the sung voice over the piano into a finished mix (vocal chain, voice in front, -14 LUFS), and exports zero-aligned full-length stems plus a tempo-map and marker MIDI file and import notes for Logic Pro. Use when someone wants to render or re-render a planned layer, hear the plan with its candidat

How it works

  1. Refuse to run without an approved plan
  2. Workflow
  3. The finished mix of a sung line
  4. Measurements
  5. Export to Logic Pro (see references/targets.md)
  6. What "done" looks like
  7. The contract (see references/responsibility-matrix.md)
Original SKILL.md headings · 110 lines, 861 words
SKILL.md preview
---
name: arrange-render
description: Render, mix and export an approved ARRANGE plan. Runs the plan's instrument layers with ACE-Step 1.5 (Lego, one layer at a time on the context the plan declares), records every candidate on the plan, measures each one against the piano (chroma, level, vocal pitch), makes a listening preview, polishes the sung voice over the piano into a finished mix (vocal chain, voice in front, -14 LUFS), and exports zero-aligned full-length stems plus a tempo-map and marker MIDI file and import notes for Logic Pro. Use when someone wants to render or re-render a planned layer, hear the plan with its candidates, finish the mix of a sung line over the piano, or get stems into a DAW. The Mix step of the ARRANGE chain. Never decides what goes where (that is /arrange-plan) and never picks a candidate for the creator.
---

# /arrange-render

The last step of the ARRANGE chain:

Listen → Play the Line, Fit, Sing (`/arrange-lyrics`) → Plan (`/arrange-plan`) → **Mix** (`/arrange-render`)

You take the approved **`arrangement.json`** and the piano recording and produce
candidates for each layer, measurements, a listening preview, a finished mix of
the sung voice, and a **Logic Pro import folder**. You make no editorial
decisions: the plan says which layers, where, how, hearing what, in which order.
You execute that, measure the result, and tell the truth about it. Read
`references/arrangement-schema.md` (the input), `references/backends.md` (how
each job runs), `references/verification.md` (what is measured) and
`references/targets.md` (the Logic export) before the first run.

Setup: the backends find ACE-Step and SoulX-Singer through the ARRANGE config or
`ARRANGE_*` environment variables (`docs/setup.md` in the repository). The
scripts import the plan library from `/arrange-plan`, so install the ARRANGE
skills side by side.

## Refuse to run without an approved plan

| Missing | What you do |
|---|---|
| `arrangement.json` | **Stop.** Offer `/arrange-plan`. Do not invent layers from a notebook or a description. |
| The piano recording | **Stop.** Everything is conditioned on it and aligned to it. |
| A backend a job needs (ACE-Step not installed, no base checkpoint) | Render everything else; leave the affected layers stubs with a reason (a `set_stub` revision in `/arrange-plan`). Never substitute a different backend or route on your own: that is a plan change. |
| `open.unresolved_specs` is non-empty | Proceed, trusting the plan as written, and say which layers were rendered under uncertainty. |

## Workflow

Render each layer in the plan's `order`, register its candidates, then measure,
preview and export:

```
# an instrument layer (audio route): ACE-Step Lego on the context the plan declares
python scripts/backends/ace_step.py --plan arrangement.json --layer L4 --spine piano.wav --build build/ [--variants 3] [--seed N]
python scripts/register.py arrangement.json L4 build/L4/candidates.json
# a sung layer: rendered by /arrange-lyrics (sing.py, from the approved fit), then registered here
python scripts/register.py arrangement.json L1 <project>/build/voice/candidates.json
# measure, preview, export
python scripts/verify.py arrangement.json piano-analysis.json --spine piano.wav -o build/measurements.json
python scripts/mix.py arrangement.json --spine piano.wav -o build/preview.mp3 [--window 68 118] [--pick L4=L4c2] [--gain L1=-3]
python scripts/export.py arrangement.json piano-analysis.json --spine piano.wav -o export/logic [--midi analysis/piano.mid]
```

`register.py` marks the first rendered candidate as provisional unless the
creator has already chosen. The creator's choice is a revision in
`/arrange-plan` (`choose_candidate`), never made here.

**Conditioning order matters and is not yours to change.** A layer's context
contains only what the plan says it hears. Rendering the strings before the
vocal because the vocal backend is slow would change what the strings respond
to; if the order is impractical, say so and let the creator decide in the plan.

**Every candidate is full-length and zero-aligned.** It starts at the
recording's t = 0 and is padded with digital silence outside the layer's
window, so in the DAW every stem goes to bar 1 and nothing needs positioning.

## The finished mix of a sung line

For a sung line over the piano, `polish.py` makes the record-like mix: the voice
cleaned and compressed, a small plate, the piano given a little of the same
space and a dip where the consonants live, the voice +6 dB over the piano on
the sung stretch, the bus at -14 LUFS and -1 dBTP:

```
python scripts/polish.py --voice <project>/build/voice/<take>.mp3 --recording piano.wav \
    --score <project>/build/sung-score.json --window 0 70 -o polished.mp3 [--preset light|clean|touch|warm|bright|dry]
```

`--preset dry` gives the same balance with no effects, as an A/B reference.

## Measurements

`verify.py` writes, per rendered candidate: chroma similarity to the piano over
the layer's window, level against the piano, and for sung layers the share of
frames in tune with the score. No thresholds are applied (see
`references/verification.md`). Present the numbers next to the previews, then
**stop and hand the choice to the creator**. If every candidate of a layer is
poor in the same way, that is not a bad seed; it is a plan problem (wrong
prompt, wrong route, wrong context): say which, and point to `/arrange-plan`.

## Export to Logic Pro (see references/targets.md)

`export.py` writes `export/logic/`: `stems/NN_<name>.wav` (zero-aligned,
full-length, 24-bit, numbered in `order` with the piano as `00`; stubs end in
`_STUB`), `tempo-markers.mid` (the tempo map so Logic's grid follows the
performance, the time signature, section markers, the transcribed piano and
the vocal score), `IMPORT.md` (the import steps), and copies of the plan and
the analysis. Every layer appears as exactly one stem; `export.py` refuses to
write the folder if any layer has none, and says which.

## What "done" looks like

1. The export folder, the preview, and the measurements.
2. A one-screen summary in musical language: which layers rendered, which are
   stubs and why, the measurements per candidate, the candidates waiting on the
   creator's ear, and anything rendered under uncertainty.
3. What to change in `/arrange-plan` if they want a different result, never a
   tweak you made yourself.

## The contract (see references/responsibility-matrix.md)

Render owns execution, measurement, parity and export. It does not own which
candidate ships (the creator chooses by ear), nor any change to a layer's
class, prompt, anchors, route or context. When a result is bad, the fix is a
revision in `/arrange-plan`, and you say so.
Files in this package (16)
  • SKILL.md 7 KB
  • examples/arrangement.example.json 12 KB
  • references/arrangement-schema.md 6 KB
  • references/backends.md 2 KB
  • references/responsibility-matrix.md 7 KB
  • references/targets.md 2 KB
  • references/verification.md 2 KB
  • scripts/export.py 9 KB
  • scripts/mix.py 3 KB
  • scripts/polish.py 7 KB
  • scripts/register.py 4 KB
  • scripts/smf.py 7 KB
  • scripts/stub.py 2 KB
  • scripts/verify.py 5 KB
  • scripts/backends/ace_step.py 9 KB
  • scripts/backends/soulx.py 11 KB

Versions

The database has no other skills named arrange-render.

Database snapshot: 13.11.2026 · package version 700fd6679a5a (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100arrange-plan
    Turn an ARRANGEMENT.md notebook plus piano-analysis.json (and any human-take catalogue) into arrangement.json, the plan of which layers exist, where each enters and exits as bar:beat anchors with seconds derived from the measured tempo map, how each is produced (ACE-Step for…
  • 100arrange-lyrics
    Put a composer's words on a melody they play over their own piano recording, show it engraved on a Score Canvas, sing it in a chosen voice and check it. Use when someone wants to play a vocal line on keys over a recording and tap the beat, fit lyrics to the notes they played,…
  • 100mix-master
    Mix the vocal and instrument stems and master the song for streaming, video and in-game playback, gated by measured loudness, true peak, the encoded-file check and the phone-speaker vocal check, with the numbers written down. Use when stems are ready, for "mix this", "master my…
  • 90vocal-chain
    Use when the user has recorded vocals and wants a processing chain set up. Examples - "set up my vocal chain", "process this vocal", "make the vocal sit in the mix", "give me a pop vocal chain", "make this rap vocal aggressive".
  • 100audio-to-midi
    Convert MP3/WAV/FLAC audio files to MIDI (.mid) and MusicXML (.musicxml) with full music analysis. Two engines: Basic Pitch (general-purpose polyphonic) and Piano Model (high-accuracy piano, 96.7% F1). Optional Demucs stem separation. Use --engine piano for piano/keyboard music…
  • 100video-to-piano-sheet
    Turn an MP4 piano video in which the pressed keys light up clearly (falling-notes / Synthesia-style keyboard video) into two-hand piano sheet music (PDF + MusicXML + MIDI). Use when the user sends an .mp4 and asks for piano sheet music / โน้ตเปียโน / ชีทเปียโน from it.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.