User manual

Welcome

KEDITOR GRAND is an acoustic piano editor for the Kurzweil K2700. A patch starts from one of five sampled pianos and puts a room around it: a lid you open with the mouse, a microphone you move nearer or further away, a voicing EQ, the sympathetic resonance of the strings, the release, the key and pedal noises, a compressor, a tempo delay and a hall reverb. The app plays the pianos itself, so you can shape a patch with or without the instrument; with the K2700 connected, the K2700 plays the patch and follows every move.

• Every control is a K2700 control. Each knob, slider and button of the panel sends the MIDI controller that one of the K2700's own knobs, sliders or buttons sends in Program mode. A patch stored on the K2700 keeps answering the instrument's panel without the app.
• Five pianos, each with its velocity layers, its pedal-down resonance, its key-release samples and a room of its own on screen, and 128 USER places for your patches.
• A sampler that records a piano of your own, from an instrument or an AU plugin, finds its loops and builds it into a piano of the app and a .K27 file for the K2700.

Getting started

What you need

• A Mac with macOS 12 or later, and about 2.3 GB of free space for the five pianos.
• For the LINK, STORE and READ: a Kurzweil K2700 and a USB cable to its USB computer port. MIDI and audio travel on the same cable.
• For the sampler: an instrument with an audio output and a MIDI input (or the K2700 itself), or an Audio Unit instrument plugin installed on the Mac.

First sounds

1. Open KEDITOR GRAND. It starts on the Grand Intimate and its first patch, 01 Concert Lid, and the lid opens by itself to show that it moves.
2. Play the keyboard at the bottom of the window with the mouse: the higher up a key you press, the softer; the lower down, the louder. Or play a MIDI keyboard (see The keyboard and MIDI).
3. Step through the patches with ◀ ▶, or click the patch's name for the list.
4. Drag the lid, drag the microphone, turn a knob. The patch shows EDITED; WRITE keeps it in a USER place.
5. Choose another piano under PIANO. It loads in the background and takes over between two audio blocks, with the controls as they were.

With your K2700

1. Install each piano on the K2700 once, from its .K27 file (see Installing the pianos on the K2700).
2. Open CONFIG, choose the K2700's MIDI port, turn the LINK on, SCAN and FILL FROM SCAN (see CONFIG).
3. Move any control: the K2700 takes the patch and plays it. STORE ON K2700 keeps it there as a program.

The Mac menus

The window at a glance

Knobs, buttons and the K2700 tags

Each control carries a small tag with the K2700 control that moves it: K1 to K9 for the knobs, S1 to S9 for the sliders, B1 to B9 for the buttons. Hover a control to read what it does and the controller value it sends.

DELAY TIME and REVERB TYPE move from step to step: the note values and the rooms. A section's switch (the black button with a red light in its title bar) takes the whole section in or out; its knobs dim while it is out.

Patches

A patch is a piano and everything around it: the lid and how it is released, the microphone, the EQ, the string resonance, the release, the noises, the compressor, the delay, the reverb and the Dynamic Response Curve.

Choosing a patch

• ◀ ▶ step through the patches of the piano chosen under PIANO: its presets first, numbered within the piano (01, 02 …), then your USER patches made on it.
• A click on the patch's name opens the same list.
• Choosing another piano opens its first patch.

The starter patches

A piano you build with the sampler starts with the patch that was open; make its own patches with WRITE.

EDITED and WRITE

Any change, in the app or from the K2700's knobs and sliders, marks the patch EDITED. WRITE keeps it in one of the 128 USER places, U01 to U128, with a name of up to 16 characters. WRITE proposes the patch's own place when it already has one, otherwise the first free place; a place that holds another patch is replaced only after you say yes. Your patches are kept in the app's data folder, one line each in my_patches.txt.

The pianos

The PIANO list holds the five pianos of the app, then any piano you built with the sampler. One piano plays at a time: the one the patch names, or the one you choose here. It loads in the background, and the app keeps playing the one before until it is ready.

Every piano has a pedal-down layer for each velocity layer (the strings ringing with the dampers up), key-release samples recorded at three dynamics, and the K2700's own pedal noises. A piano takes about twice its size in memory while it plays; changing piano reuses the space of the one before.

Not installed, K2700 only

• A piano of the app whose folder is not in the data folder (Pianos) is listed greyed out, NOT INSTALLED.
• Some of the K2700's own factory pianos are listed at the end for reference, greyed out: the app does not play them (their samples are the instrument's).

Each piano's room

The room is redrawn for each piano: walnut boards and a midnight-blue oval rug for the Grand Intimate, wide pale ash boards for the Bright German, a near-black stage floor and a burgundy rug for the Concert Grand, honey chevron parquet and a terracotta round rug for the Italian Grand, cherry basket-weave parquet and a forest-green rug for the Classic Upright. The shadow on the floor is the piano's own.

The room

THE ROOM is the left of the window: the piano, its lid and the microphone on its stand. Hover the lid (the hand cursor) or the microphone (the move cursor) and drag.

The lid

The lid is an EQ in the piano's effects, moved by slider 7 (CC 26): up opens it. It has three stops, CLOSED (0°), SHORT STICK (10°) and FULL STICK (38°).

• Drag the lid up or down. With ON STICK, it settles on the nearest stop when you let go, carried a little by the speed of your hand; with HOLD, it stays exactly where you leave it.
• The stop buttons under the room set it at once; with the room clicked, ↑ / → raise it to the next stop and ↓ / ← lower it.
• The ANGLE slider in the bottom strip sets any angle from 0 to 38°, half a degree at a time.

Closed, the lid adds +2 dB at 150 Hz and +3 dB at 450 Hz, takes 6 dB off at 4 kHz and 12 dB off above 2.5 kHz, and lowers the whole piano by 6 dB; on the full stick it does nothing. Measured at C4: closed, 15.6 dB less above 6 kHz and 4.2 dB less in all; on the short stick, 5.4 dB and 1.4 dB. The bottom strip shows the ANGLE, the value of CC 26 and what the lid takes off AT 8 kHz.

On the Classic Upright the lid is the top lid, hinged at the back: CLOSED, HALF OPEN, OPEN, on the same slider. The sound leaves through the opening.

The microphone

The microphone blends a small, dry studio room into the direct sound, moved by slider 8 (CC 27): up takes it further away. Drag it along the floor, choose CLOSE (0.35 m, at the hammers), NEAR (1.2 m) or ROOM (2.4 m), or use the POSITION slider in the bottom strip.

As it moves away the room's early reflections grow and darken, and the direct sound falls: at NEAR the piano is 2.5 dB down in all, at ROOM 8 dB. The key-release and pedal noises fall with the distance too, 6 dB at ROOM.

SOUND PATHS

SOUND PATHS draws the sound leaving the strings and reaching the microphone. With the lid just open, up to the short stick, a tag says HIGHS STAY UNDER THE LID: that is the lid's EQ at work. Switch it off for a quieter picture; it changes nothing in the sound.

The rack

The right of the window holds the piano's sound shaping, in the order the sound goes through it.

EQ · VOICING + LID

The graph shows the EQ's total curve and, dashed, the part the lid adds. The five knobs are the piano's voicing EQ; the switch in the title bar (ON, button 1, CC 80) takes the voicing EQ and SIZZLE in or out; the lid's EQ stays.

STRING RES

The sympathetic resonance of the undamped strings: ON (button 6, CC 86) and AMOUNT (slider 6, CC 25), 0 to 100 % wet.

RELEASE

How long the notes ring after the keys are let go (slider 4, CC 23): ×1 is the piano's own dampers, ×8 eight times as long.

NOISES

KEY RELEASE (slider 1, CC 12) is the sound of the dampers falling back as a key is let go; PEDAL NOISE (slider 3, CC 22) the sustain pedal's own sounds. Both are off at 0; from there they go from −40 dB to 0 dB at 85 (the piano's own level) and +20 dB at the top. The key releases also follow how hard you played: at the softest, 19 dB down. Both fall as the microphone moves away. The pedal noises play on the K2700 only: their samples are the instrument's own.

COMP

A soft-knee compressor at 3:1 that evens out the dynamics (knob 5, CC 14). At 0 it is out of the sound; at the most, the 22 dB between a note played at velocity 40 and one at 127 become 12 dB.

DELAY

A single echo that repeats, in note values at the tempo (on the K2700, the K2700's tempo).

REVERB

The hall around the piano.

The way the sound goes

Every piano uses the same three effect chains, its own copies on the K2700. The delay and the reverb are true sends: the direct sound stays whole, and they add to it.

piano ─▶ GRAND Insert: string resonance ▶ compressor ▶ lid EQ ▶ microphone room ▶ voicing EQ + SIZZLE ─▶ out
                                                                                        ├─ aux 1 ▶ GRAND Hall  (REVERB)
                                                                                        └─ aux 2 ▶ GRAND Delay (DELAY)

Dynamic Response Curve

A piano is sampled in velocity layers, each one played in its own window of velocities. The Dynamic Response Curve decides which layer each velocity you play reaches.

The curve

The left graph takes the velocity you play (across) to the velocity the layers see (up).

• LINEAR: the windows the piano was made with.
• SOFT: above the diagonal: a lighter touch reaches the strong layers.
• HARD: below it: the strong layers ask for more force, and more of the range is given to them.
• Drag either of the two points: the curve passes through 0, the two points and 127, always rising. The mode then reads CURVE.

The velocity layers

The right graph shows each layer as a column with its bar over the velocities that play it, and the window written under it. Drag a boundary between two layers to set it by hand: the mode reads MANUAL, and the curve on the left passes through every boundary.

What follows the windows

The new windows take effect between two audio blocks, without cutting notes. The notes, the pedal-down resonance, the undamped top and the key releases all follow them; the key releases also change level with the middle of their window, as they do across the piano's own layers. The curve is part of the patch: it goes with WRITE, the LINK, STORE and EXPORT. On the K2700 the windows are data of the program.

K2700 CONTROLS

This tab draws the K2700's control section, with what each control does in this patch and its value now. Every control on it is a control of the app: move one here and the app's panel follows; move it on the K2700 and this tab follows. The patch shows EDITED either way.

Buttons 2, 3, 4, 5 and 7 are shown dimmed: they are kept free. The sustain pedal is beside the keyboard (CC 64). Under the controls, ONLY IN THE APP names the two settings the K2700's panel does not move: the lid's release (ON STICK or HOLD) and the Dynamic Response Curve, which goes to the K2700 with STORE.

The keyboard and MIDI

• The keyboard has 88 keys, A0 to C8, and plays the app's piano. The velocity comes from where you press: 20 at the top of a key, 127 at its front. VEL shows the last one. Several fingers on a touch screen play several notes.
• SUSTAIN is a latching button: click to hold the pedal down (CC 64), click again to let it go.
• A MIDI keyboard plays the app too: choose it in the MIDI menu. Its sustain pedal works as the K2700's.
• Controllers in: the K2700's knobs, sliders and buttons, or any controller that sends the same CCs, move the panel as if you moved it there. The patch shows EDITED, and WRITE and STORE keep what they set.

Installing the pianos on the K2700

Each piano is a .K27 file: its program, the three GRAND effect chains it points at, its keymaps and its samples with their sound (16-bit). The pedal noises are the K2700's own and stay as references. Install a piano once; then any number of patches can use it.

The files are in the app's data folder, under K2700. EXPORT writes a piano's file again at any time, with PIANO + PATCHES (see EXPORT).

1. Copy the file to a USB stick and plug it into the K2700.
2. On the K2700: GLOBAL > FILE > LOAD, choose the file, then FILL. The objects go to free USER IDs, and the K2700 sets the references between them.
3. Repeat for each piano you want. Then, in the app, CONFIG: LINK, SCAN, FILL FROM SCAN.

Each piano needs as much free sample memory on the K2700 as its file's size.

CONFIG

CONFIG says where each piano is on your K2700: the ID of its program and of its three chains, INSERT, HALL and DELAY. The app needs them to send a patch to the K2700 and to store it.

The K2700 line

MIDI PORT (the K2700's USB port), CHANNEL (the channel the K2700 plays, 1 by default) and the LINK switch, with its state beside it. Once chosen, the port and channel are kept.

SCAN

Choose a range of USER IDs (4096 to 4351 to start; up to 1024 at a time) and SCAN: the app reads the names of the programs and chains in that range. It reads only; it writes nothing. The programs named after a piano are read in full, to learn which chains they point at. FILL FROM SCAN then puts each piano's program and its chains in place; two programs with the same piano's name are left for you to choose.

The IDs

• Type an ID (0 or empty: not set), or pick one from the scan with ▾: the ones with the right name come first. Choosing a program brings the chains it points at.
• CHAINS FROM PROGRAM sets a piano's three chains again from its program, as the K2700 holds it.
• Under each ID, what the scan found there: ✓ and the right name, ≠ another name, empty on the K2700, program uses N (the chain is not the one the program points at), or not read.

Each change is kept at once, in k2700_ids.txt. The LINK light in the header opens CONFIG.

The LINK, STORE and READ

What the LINK does

1. Turning it on sends nothing. The K2700 keeps playing what it played; the LINK line says it takes the patch at your next change.
2. Your next change (opening a patch, choosing a piano, moving the curve or the first control) sends the patch into the K2700's edit buffer: the piano's program as the K2700 holds it, at the ID in CONFIG and checked by name, with the patch in it (its controller values, its velocity windows, its name). The first time the whole program goes; after that, only the parts that changed. Nothing is written to the K2700's memory.
3. Each control's value follows once, so that the K2700's knobs and sliders start from the patch and not from where the last program left them.
4. Then every control goes live on the LINK's channel: the 22 knobs, sliders and buttons, the lid and the microphone, at most once every 10 ms for each control, and always its last value.

The line under the LINK light says what the K2700 plays, for example the K2700 plays Concert Lid (Grand Intimate, 4096), or why it does not: a piano without IDs in CONFIG, or an ID that holds another program.

STORE ON K2700

Writes the patch as a USER program named GRD and its name (up to 12 more characters), at an ID from 4096 to 8191: the first free one, or the one you used last time for this patch.

• It never writes over a piano's own program (the IDs in CONFIG), and never over another object without your yes.
• It reads the program back to check: read back: the same.
• The program's Info keeps the rest of the patch: the piano, the lid and its release, the microphone, the curve.

READ FROM K2700

Brings a program back as a patch: its piano, the controls from its controller values, and the lid, microphone and curve from its Info (or from CC 26 and 27 in a program not made by the app). The dialog proposes the GRD programs the last scan found. A program whose piano the app does not know is not read as a patch.

Turning the LINK off while a request is on its way answers it at once: nothing is left waiting.

EXPORT

EXPORT writes the patches of the piano chosen under PIANO as a .K27 file for the K2700, without the LINK. Each patch becomes a program named GRD and its name, exactly as STORE would make it.

• PATCHES: tick the patches (ALL, NONE): the presets, your USER patches, and the patch open now, as it is now if it is EDITED.
• FILE NAME: up to 40 characters. Accents are taken out, and ? * " < > | become a dash, for the USB stick's file system. A file of the same name is replaced only after your yes.
• The file goes to the data folder's K2700 folder; at the end, SHOW IN FINDER.

PATCHES ONLY needs the piano's ID in CONFIG and its program read from the K2700 once: the app keeps a copy each time the LINK reads it (when a patch plays, on STORE or EXPORT). If it has never been read, the dialog says what is missing; PIANO + PATCHES is then the way.

On the K2700: GLOBAL > FILE > LOAD, the file, FILL. The programs go to free IDs; find them by name.

NEW PIANO SAMPLER

The sampler records a piano key by key and layer by layer, and builds it into a piano of the app, with a .K27 for the K2700. It opens over the whole window with NEW PIANO SAMPLER; BACK TO THE EDITOR closes it, and the session is kept.

Sessions

Each piano is a session: its name, its source and setup, its calibration, its takes and the piano built from them, kept on disk as it goes. Stop at any time, close the app, and go on later.

• A NEW PIANO: type its name (up to 16 characters) and START THE NEW PIANO (or Return). A name already used by a piano or a session is refused. The new session starts with the source and setup of the last one; its calibration, its takes and its piano are its own.
• OR GO ON WITH A SESSION: the sessions with takes, the last one first, each with its count of takes and whether it is built. CONTINUE opens it at the step where it stands: still recording, RECORD; takes marked, REVIEW; all good or built, BUILD.
• In the steps, the right column shows THE SESSION: the list of sessions and NEW, the piano's name, its source, format, layers and keys, the takes recorded, to check and to redo, the recording time, the size on the K2700, and the layers the program will have, out of the K2700's 32.

The six steps

SOURCE ▶ SETUP ▶ CALIBRATE ▶ RECORD ▶ REVIEW ▶ BUILD. Click a step to go to it, or use ◀ BACK and NEXT ▶. A done step shows a tick.

THE KEYS

The keyboard under every step shows the plan: the recorded keys, the keys each one plays, where the dampers end, and while recording, each key's state: grey to record, green done, amber to check, red to record again, pink recording now. In SETUP, drag FROM, TO and DAMPERS along it.

SOURCE

Where the sound comes from.

AN INSTRUMENT

A piano, a K2700, a sound module: its audio into the Mac's audio input, the notes and the sustain pedal sent to it over MIDI.

• AUDIO INPUT and INPUT CHANNELS (the pair, or one channel for mono). An input that is not at 48 kHz is flagged.
• MIDI OUTPUT and MIDI CHANNEL; the sustain pedal goes as CC 64.
• The INPUT LEVEL meters and TEST NOTE, a C4 at velocity 100 for one second.
• The first time, macOS asks for access to the microphone. An input that gives only digital silence for 2 s says so: allow the access in System Settings > Privacy & Security > Microphone.

AN AU PLUGIN

An instrument plugin on the Mac: a piano library, a synth. It runs in a process of its own (a plugin that crashes does not take the app with it) and is played offline, as fast as it computes, often many times faster than real time.

• PLUGIN: the Mac's AU instruments, by maker; FACTORY PRESET, when the plugin lists them.
• OPEN ITS WINDOW: the plugin's own window, to choose and adjust its sound. What you set there is kept with the session, and the plugin opens with it next time.
• TEST NOTE, and a status line: loading, loaded, its window open, how fast the last job ran.

TEST: THE APP'S PIANO

The app's own engine playing one of its pianos (without effects), as fast as it can: a whole session in seconds. It is there to try the sampler without an instrument.

FORMAT

48 kHz, STEREO or MONO. On the K2700 every sample is 16-bit, each root brought up to full scale.

SETUP

What to record. Each change goes into the session at once; when takes are already recorded, the page says that a change keeps the takes that stay the same, and the others will be recorded again.

VELOCITY LAYERS

HOW MANY: 1 to 8 layers (3 at least with key releases: one for each of their dynamics). Each layer is recorded at its velocity; drag a bar to set it, or SPREAD EVENLY. The program plays each layer from halfway to the layer below to halfway to the layer above; the windows are written under the bars.

WHAT THE PIANO HAS

• PEDAL DOWN TAKES: each key again with the sustain pedal down, the strings' resonance; the program crossfades to them when the pedal is down as a note starts. Without them the pedal simply holds the notes.
• KEY RELEASES: the dampers' sound as a key is let go, at three dynamics.
• PEDAL NOISES: the K2700's own pedal sounds (not recorded).
• AN ACOUSTIC PIANO sets all three, with the dampers ending at E6; AN ELECTRIC PIANO none, with a damper on every key (C8), so that the notes stop when the keys are let go.

KEYS

• FROM and TO: the keys to record; the lowest and highest recorded keys also play the keys beyond them.
• DAMPERS END AT: the last key with a damper. Above it the strings ring on when the key is let go: those keys get no pedal-down take and no key release. E6 is where the dampers end on most grand pianos; C8 means a damper on every key.
• ONE RECORDED KEY EVERY 1, 2, 3, 4, 6 or 12 semitones. Each recorded key plays the keys halfway to its neighbours.

TIMING

The right column's RECORDING TIME and ON THE K2700 estimate follow every change.

CALIBRATE

Three measurements before recording; MEASURE each, or MEASURE ALL.

Without a measured noise floor, recording measures it first, with the instrument quiet before the first note.

RECORD

Layer by layer, everything automatic: each key, then the same key with the pedal down (when the piano has them), and the key releases at the end.

• The take being recorded: its pass, velocity and key, pedal up, down or key release; its level and peak live, with the note, the steady part and the key's release marked; the progress in all and by pass (N notes, P pedal, R key releases); the log.
• START RECORDING / CONTINUE, PAUSE AFTER THIS TAKE, STOP NOW, RECORD THE LAST AGAIN, START ALL OVER.

When a note stops

A note records until its decay holds steady: two windows in a row after the peak (0.8 s each, 1.2 s below C3) with the same slope, no bumps, the same timbre band by band, the note well above the noise, and at least the shortest length recorded. Then the key and the pedal are let go and a quarter of a second more is kept. A note that never steadies stops at the longest length; one that dies away first (the undamped top) keeps its steadiest part, or needs no loop at all.

A key release holds its key for the time set, lets it go and records until its sound has gone, between 0.5 and 4 s after the key.

Each take's state

However a take ends (STOP, an input that goes silent, the app closing), the key and the pedal are let go, and at the end of each recording an all-notes-off follows.

REVIEW

Every take gets its sample and its loop as soon as it is recorded. REVIEW is where you check them, change them and record again.

EVERY TAKE

The grid has a row per pass (notes, pedal and key releases, by layer) and a column per key. Click a take to open it. SHOW brightens ALL, the MARKED ones, those with a loop set BY HAND (a white corner), the ACCEPTED ones (an amber outline) or those CHANGED SINCE BUILD. FIND ALL LOOPS AGAIN searches every take's loop again (not those set by hand, and keeping the old one when the new is not better). RECORD THE N MARKED AGAIN records the takes to redo and to check, except those accepted or with a loop set by hand; it asks first and says what it leaves out.

One take

The waveform shows the take with its level, where the sound starts, the attack (shaded), where it holds steady, the loop in pink between its start and end, the crossfade as a band above it, and the key's release. Under it, THE LOOP'S JOINT: the end of the loop and then its start, as they play; the line should run on without a step. Beside it, the measures:

Listening

• ▶ PLAY: the sample as the program will play it: the sample, then the loop again and again, falling as the loop decays.
• ▶ THE LOOP: the loop alone; ▶ THE TAKE: the take as it was recorded; ■ STOP.

Changing a loop

• Drag the pink ends. Each one goes to the nearest point the technique turns on; hold ⌥ to keep it exactly where you let go. Esc in the middle of a drag cancels it.
• ◀ ▶ under START and END move an end to the previous or next point.
• Mark a window: drag anywhere else on the waveform (a click takes it away). FIND IN THE WINDOW searches it with the four techniques, for loops from a quarter of the window to all of it, and lists the two best of each, each with its measures: ▶ to hear it as the program would play it, ▶ LOOP, and USE. The one in use is marked IN USE.
• UNDO: back through the loops the take has had (up to 40, kept with the session). AUTOMATIC: the loop the recording gave. FIND THE LOOP AGAIN: a wider search with the take's technique.
• ZOOM switches between the whole take and the loop; the mouse wheel zooms around the pointer down to single samples (Shift: along the take).

Changing the technique looks for that technique's best loop near the one you had. A loop always starts after the attack, ends before the key's release, and lasts 20 ms (or two periods) at least. Key releases have no loop.

Keeping the work

• ACCEPT · IT SOUNDS RIGHT clears an amber take you have heard: it no longer counts as to check, and is not recorded again. Changing its loop takes the acceptance away; UNDO gives it back.
• ● RECORD AGAIN asks first and keeps the recording it replaces: THE TAKE BEFORE swaps them back, and PUT BACK restores the takes waiting to be recorded again.
• When the piano has been built and takes have changed since, a band says THE PIANO BUILT IS OLDER THAN ITS SESSION, with how many takes changed: BUILD again.

Keys in REVIEW

BUILD

BUILD makes the session into a piano of the app, on the same pattern as the five pianos: the same three effect chains, the same 22 controls, the same Dynamic Response Curve.

The options

• AT THE LEVEL OF THE OTHER PIANOS: measured at C3, C4 and C5 and set to the level of the app's pianos, so that patches move between them.
• KEY RELEASES BY THE SAME LAW AS THE OTHERS: the loudest at its recorded level, the others falling as in the app's pianos (−19 dB at the softest); off, each at its recorded level.
• TUNING: KEEP IT AS RECORDED, or CORRECT TO EQUAL TEMPERAMENT (each note's pitch measured and set as its root's).
• ALSO WRITE THE .K27 FOR THE K2700.

The stages

BUILD THE PIANO (it says why while it cannot: takes to record, to redo or without a sample) lights each stage as it runs; STOP stops it and leaves nothing half done.

The program's layers

With eight layers that makes 29 program layers; the K2700 takes 32.

THE PIANO BUILT

Its name in the PIANO list, its layers, keymaps, samples and roots, its size on the K2700, its level and gain, the .K27, and notes on the envelopes and velocity tracking. ▶ PLAY IT IN THE EDITOR closes the sampler and opens the piano in the editor. On the K2700, install its .K27 as any piano (see Installing the pianos on the K2700).

Building again replaces the piano and its .K27; it never takes another session's piano or one of the app's.

Files and folders

Everything is in Documents/KEDITOR GRAND (File > Open Data Folder).

When something is not right