Kebarp User Manual

Kebarp is a fast, grid-based MIDI arpeggiator. Draw a shape on its grid, play a note from any MIDI source, and Kebarp turns that single note into a live, evolving arpeggio — as a standalone app or as an AUv3 MIDI effect inside your favorite host. Kebarp also bundles a bonus companion plugin, Keboard, a scale-locked keyboard, CC ribbon, and MPE controller you can use to play Kebarp (or any other instrument) from a touchscreen.

Overview

Kebarp is not a synthesizer — it's a MIDI arpeggiator/processor. It listens for a note coming from a MIDI keyboard, controller, or host track, and plays back a sequence of related notes built from a pattern you draw on its grid. Every note in that pattern is expressed as a scale-degree offset relative to whatever note you play, so the same pattern automatically transposes and re-keys itself to follow you around the keyboard.

The name is a pun: you place your notes — the "kebabs" — onto the grid, which is literally called the Grill.

Kebarp ships in two forms:

• Standalone app — includes its own transport, MIDI routing, Ableton Link support, and an optional internal synth so you can hear results without any other gear.
• AUv3 plugin — a MIDI effect you insert ahead of an instrument in a compatible host. It does not produce sound on its own; it only outputs MIDI.

Alongside Kebarp is a second, bonus AUv3 plugin called Keboard. It's designed mainly to make it easy to latch a note onto Kebarp and drive it hands-free, but underneath that it's a complete on-screen note, CC, and MPE controller in its own right. It ships as an AUv3 MIDI effect only (no standalone app). See Keboard Companion Controller.

How Kebarp Works

Each step in Kebarp's pattern is either:

• A number — the number of scale steps above or below the root note to play (0 is the root itself, positive numbers move up the scale, negative numbers move down), or
• A rest — an empty step that plays nothing.

When you send Kebarp a MIDI Note On, it treats that note's pitch and octave as the "root" for the arpeggio. It builds a run of notes across your chosen scale and octave range, finds your root note inside that run, and then walks through your pattern's steps, offsetting from the root by each step's number to produce the actual notes it sends out. Because everything is relative to the root, drawing a pattern once means it works in any key or octave you play it from.

As long as you hold at least one note, Kebarp keeps sequencing. Releasing a note removes it from the list of held notes; if other notes are still held, Kebarp keeps using the most recently pressed one as the root. Releasing every note stops the arpeggio and sends note-offs for anything still sounding.

Interface Overview

The main screen is built around three areas, stacked vertically:

• The Grid (top) — the large step/scale grid where you draw your pattern.
• Control Strip — a scrollable row of knobs for octave range, shift, step count, rate, gate, velocity, and swing. On wide/landscape layouts this strip moves into the bottom bar; on narrower/portrait layouts it gets its own row above the bottom bar.
• Bottom Bar — the Patterns strip (with pattern-switching buttons and a "+" to add a new pattern), a Scale button, a Clear button, and a Settings button.

Getting Started

1. Standalone: launch Kebarp and make sure a MIDI input is enabled (see MIDI Routing). AUv3: insert Kebarp as a MIDI effect ahead of an instrument track in your host.
2. Draw a pattern on the grid — tap or drag across cells to place notes, tap an existing note to clear it back to a rest.
3. Dial in Scale, Min/Max Octave, Shift, Step Count, Rate, Gate, Velocity, and Swing using the Scale button and control strip.
4. Play and hold a note from your MIDI source. Kebarp uses it as the root and starts sequencing your pattern immediately.
5. Switch between multiple patterns live, or turn on Pattern Chaining to let Kebarp move through them on its own.
6. Save your setup as a preset from Settings → Presets → User Presets so you can recall it later.

The Grid

The grid is Kebarp's signature control. Its columns are the pattern's steps (left to right, in playback order); its rows are scale-degree positions, covering everything from the current Min Octave up to the current Max Octave.

• Row labels show each row's scale-degree number relative to the root (for example 1, 2, 3, and negative numbers for degrees below the root). Rows that land on the root of an octave are labeled in bold white; all other scale-degree rows use a dimmer label color, and the grid shades every octave's worth of rows with alternating background bands so you can spot octave boundaries at a glance.
• Drawing notes: tap an empty cell to place a note there, or drag your finger across the grid to quickly paint a run of notes across several steps at once. Kebarp supports drawing with multiple fingers at the same time.
• Removing notes: tap directly on an existing note to remove it and turn that step back into a rest.
• Contour graph: a soft curved line is drawn connecting your placed notes, visually tracing the shape of the pattern.
• Playback highlight: while the sequencer is running, the currently playing step's index and note name flash and briefly enlarge so you can follow along in real time.
• Note colors cycle through the current color theme's palette across the columns.

Control Strip

The control strip is a row of "ghost knobs." For any of them, tap the knob to open a scrollable picker of every available value, or press and drag vertically on the number itself (up increases, down decreases) to scrub through values live. The Shift and Swing knobs can also be double-tapped to instantly reset to their default value (0).

The knobs, in order:

• Max Oct / Min Oct — two octave-range knobs that set how far the arpeggiator reaches above and below the root. Note that their on-screen labels are swapped relative to what they do: the knob labeled Max Oct is the one that sets the pattern's minimum reachable octave, and the knob labeled Min Oct sets the maximum reachable octave. Widening this range gives the grid more rows to draw on.
• Shift — transposes every note in the pattern up or down the scale at once, without changing the shape you've drawn. Double-tap to reset to 0.
• Steps — sets how many steps are in the current pattern (from 1 up to 64). Shrinking it trims steps off the end; growing it appends new rests.
• Rate — sets the sequencer's playback speed, from whole multi-bar note values down to 1/64th notes, including dotted and triplet variants, plus a set of unusual fractional subdivisions (1/6, 1/10, 1/12, 1/18, 1/21, 1/24, each with dotted and triplet forms) for polymetric or generative-feeling arps.
• Gate — sets how long each note rings out, as a percentage of the step's duration.
• Variety (next to Gate) — randomizes each note's gate length around the Gate setting, by up to the amount you dial in.
• Velocity — sets the base MIDI velocity (0–127) for notes in the pattern.
• Variety (next to Velocity) — randomizes each note's velocity around the Velocity setting.
• Swing — delays every other step by a percentage of the step duration, for a swung/shuffled feel.

Root Note and Octave Range

Kebarp always plays relative to whatever MIDI note(s) you're currently holding down:

• The most recently pressed held note becomes the arpeggio's root pitch and octave.
• You can hold multiple notes; releasing one falls back to the next most recently pressed note that's still held.
• Releasing every held note stops the arpeggio and turns off any notes still sounding.
• Retrigger (Settings → Arpeggiator) controls what happens when you press a new note while the sequencer is already running: with Retrigger on (the default), the pattern jumps back to its first step; with it off, the pattern keeps playing from wherever it currently is, just transposed to the new root.

The Max Oct / Min Oct knobs (see Control Strip) set how many octaves above and below that root the arpeggiator is allowed to reach — this defines both the note range available to your pattern and the number of rows shown on the grid.

Scale System

Every pattern has its own scale, chosen from Kebarp's full scale library (major, minor, modes, blues, whole-tone, diminished, and many more). Tap the Scale button in the bottom bar to open the scale picker, which has two tabs:

• Scales — the full searchable list of available scales.
• Favorites — scales you've starred, for quick access. Tap the star icon on any scale row (in either tab) to favorite or unfavorite it.

Selecting a scale updates the current pattern immediately: the grid's rows are recalculated for the new scale, and any existing notes that no longer land on a valid row are automatically cleared to rests.

Kebarp can also be told to change its scale remotely: sending a MIDI Program Change 69 makes Kebarp read a scale that a companion app ("BrainBud") has written to shared app storage and apply it to the current pattern. By default this is recognized on any MIDI channel, not just the configured MIDI In channel.

Patterns and Pattern Chaining

A project can hold any number of patterns, each with its own grid, scale, octave range, rate, gate, velocity, swing, and shift.

• The Patterns strip in the bottom bar lists a numbered button per pattern, plus a + button that adds a new pattern by duplicating the currently selected one.
• Tap a pattern number to switch to it immediately.
• Long-press a pattern button to bring up a context menu with Copy, Paste, and Delete. Paste is only available once you've copied a pattern; Delete is only available while more than one pattern exists.
• Patterns can also be selected remotely over MIDI, using the Patterns CC# configured in Settings (see below), or from an AUv3 host via the plugin's "Pattern" parameter.

Pattern Chaining (Settings → Pattern Chaining) lets Kebarp move through your patterns on its own instead of waiting for you to switch manually:

• Pattern Chaining — turns chaining on or off.
• Repeat Count — how many full loops of the current pattern play before Kebarp advances to the next one.
• Random Order — when on, Kebarp jumps to a random other pattern instead of the next one in sequence each time it advances.

Presets

A preset captures an entire Kebarp project: every pattern, the tempo, and all settings (MIDI channels, retrigger, pattern chaining, theme, and more).

Open the preset browser from Settings → Presets. It has two tabs:

• Factory Presets — a large built-in library of ready-made patterns, spanning classic arpeggio shapes (Up, Down, Up-Down, Alberti Bass, Broken Chords...), scale-flavored patterns (Blues, Modal, Diminished Run, Whole Tone Glide, Pentatonic Flow...), genre-styled patterns (Techno, Jazz, Ambient...), and several multi-pattern Pattern Chaining demos. Factory presets can't be renamed or deleted.
• User Presets — presets you've saved yourself. Tap + to save your current setup under a new name. Swipe left on a saved preset to Rename or Delete it.

Selecting any preset (in either tab) immediately replaces your current project with that preset's patterns and settings. Use the previous/next arrows in the navigation bar to step through the presets in the tab you're viewing — Kebarp remembers your place.

User presets are stored as .kebarp files. When iCloud is available, Kebarp keeps them in an iCloud-backed folder so they sync across your devices; otherwise they're kept in local shared app storage on that device only.

MIDI Routing

In the standalone app, Kebarp always has a virtual MIDI input named "Kebarp In" and a virtual MIDI output named "Kebarp Out", which you can enable or disable from Settings. It can additionally connect to any Core MIDI input/output the system exposes (hardware, network, or Bluetooth), toggled per-port in Settings → MIDI In / MIDI Out.

• Input: note on/off, control change, and program change messages are all recognized on the configured MIDI In Channel. Pitch bend messages are received but currently have no effect on the arpeggio.
• Output: generated arpeggio note on/off events are sent out on the configured MIDI Out Channel, through whichever Core MIDI destinations and/or the virtual output you have enabled.
• Remote pattern switching: sending a control-change message on the Patterns CC# number (Settings → MIDI Settings, default CC 10), on the MIDI In channel, with a value greater than 0, switches to pattern number (value − 1). A value of 0 has no effect.
• Scale sync: Program Change 69 triggers the BrainBud scale-sync behavior described in Scale System.

As an AUv3 plugin, Kebarp receives MIDI from whatever your host routes into it (typically a MIDI track or keyboard input) and outputs its generated arpeggio as MIDI events back into the host, to be picked up by an instrument placed after it in the signal chain. The plugin itself is silent — it is a MIDI processor, not an instrument.

Standalone Audio Engine and Internal Synth

The standalone app includes its own audio engine (with Ableton Link support) so you can play Kebarp without any other software:

• Tempo (BPM) is set from Settings and drives both the internal transport and Ableton Link, if enabled.
• Ableton Link can be enabled from Settings, which opens Link's own settings/sync panel for joining a Link session on your network.
• Internal Synth is an optional built-in monosynth (saw + square oscillators through a filter and reverb) you can use to hear the arpeggio without routing MIDI anywhere else. When you press Play, the synth's own configured Key and Octave (set in Settings → Internal Synth) become the held root note, and Kebarp arpeggiates around it for as long as playback continues. Internal Synth settings include an Enabled switch, a Volume slider, a Key picker, and an Octave stepper.
• MIDI Panic (Settings) immediately sends note-off for every MIDI note on the configured MIDI Out channel — useful for clearing any notes that got stuck.
• MIDI Bluetooth (Settings) opens the system Bluetooth MIDI pairing screen so you can connect Bluetooth MIDI controllers.

AUv3 Plugin

Kebarp's AUv3 component is registered as a MIDI Processor effect, not an instrument — place it on a MIDI/instrument track ahead of a sound source in your host, so the host's instrument receives the arpeggiated MIDI that Kebarp produces.

• State saving: the plugin's full state — every pattern, tempo, and setting — is saved into your host project/session as part of normal AU state saving, so recalling a saved session restores your Kebarp setup exactly.
• Factory presets: Kebarp's built-in preset library is exposed through the host's own preset menu (where your host supports AU factory presets), in addition to the in-app preset browser.
• Tempo sync: the plugin reads your host's tempo automatically and keeps its internal rate in sync with it.
• Per-instance state: each instance of the plugin keeps its own independent patterns and settings, so you can run multiple Kebarp instances across different tracks.

Keboard Companion Controller

Keboard is a second, bonus AUv3 plugin bundled alongside Kebarp. It is a MIDI Processor effect like Kebarp itself — it ships only as an AUv3 (there is no standalone Keboard app). Its main design goal is to give you a quick, on-screen way to latch a note onto Kebarp and drive its arpeggiator hands-free: route Keboard's MIDI output into Kebarp's MIDI input, tap a scale-locked key with Latch on, and Kebarp keeps arpeggiating around that root without you having to hold anything down. Beyond that specific pairing, Keboard is a genuinely complete note, CC, and MPE controller you can point at any instrument.

Keboard's top bar has a Mode button that cycles through four modes, plus a row of controls whose meaning changes depending on the active mode:

• Mono — playing a key always leaves at most one note sounding. Pressing a new key silences whichever key was previously active before sounding the new one.
• Poly — the same key behavior as Mono, but multiple keys can sound together as a chord.
• MPE — every new key press is automatically assigned its own MIDI channel (cycling channels 2–15, per the MPE convention), and while your finger stays on an active key you can slide it: vertically for a CC 74 "brightness"-style expression message, and horizontally for pitch bend, scaled by the Pitch Bend knob's strength. Entering or leaving MPE mode sends the standard MPE configuration handshake so compatible hosts/instruments recognize the zone.
• CC — the key row stops playing notes entirely. Instead, each key sends a single MIDI CC message (using the CC# knob's controller number) with a value interpolated across the Min/Max range you've set, based on the key's position — effectively a touch ribbon controller.

Shared controls (shown for Mono/Poly/MPE; the CC mode swaps in its own controls):

• Latch — with Latch on, tapping a key toggles its note on or off; with Latch off, a key only sounds while your finger is actually touching it.
• Host Sync — when enabled, held notes are only actually sent to the host while its transport is playing; starting playback re-fires any held notes and stopping playback releases them, so you can set up a chord before pressing play. When disabled, notes are sent immediately regardless of transport state.
• Key / Scale — open the key and scale pickers; the key row is rebuilt to only contain pitches in the chosen key and scale (shared with Kebarp's own scale picker). Changing either while notes are held re-pitches them live instead of cutting them off.
• Min Oct / Max Oct — set the octave span of pitches shown across the key row.
• Velocity — the fixed velocity used for notes Keboard sends.
• Pitch Bend — MPE mode only: sets how far the horizontal slide gesture bends pitch.
• Channel — the MIDI channel used for outgoing notes (Mono/Poly/CC); hidden in MPE mode, since MPE assigns its own per-note channels automatically.

CC mode controls:

• CC# — the MIDI CC number sent by every key.
• Min / Max — the CC value range mapped across the key row, from the leftmost key (Min) to the rightmost key (Max).

Like Kebarp, Keboard also responds to a MIDI Program Change 69 by pulling a key and scale from the BrainBud companion app's shared storage and applying both to its own key row.

Keboard supports full AUv3 state saving (so a host session recall restores its mode, key, scale, octave range, velocity, channel, and CC settings) and exposes a single "Default" factory preset that resets it to its default configuration.

Settings Reference

Tap the Settings button in the bottom bar to open Kebarp's settings. Sections available in both the standalone app and the AUv3 plugin:

Section	Controls
MIDI Settings	Patterns CC# (0–127), MIDI In Channel (1–16), MIDI Out Channel (1–16)
Presets	Opens the preset browser
Scale	Opens the scale picker for the current pattern
Arpeggiator	Retrigger switch
Pattern Chaining	Pattern Chaining switch, Repeat Count stepper, Random Order switch
Theme	Color Theme picker
Support	Tutorial, Review, Other Apps, Feedback (standalone app only, hidden while running the built-in tutorial)

Additional sections available only in the standalone app:

Section	Controls
Tempo	BPM stepper (10–500)
Internal Synth	Enabled switch, Volume slider, Key picker, Octave stepper
MIDI In / MIDI Out	Virtual MIDI In/Out switches, plus a switch per detected Core MIDI port
MIDI	MIDI Bluetooth button, MIDI Panic button
Ableton Link	Enabled/Disabled status, opens Link settings

Color Themes

Settings → Theme lets you pick the grid and graph color palette from a set of built-in themes: Kebarp 🍢, Bud 🔥, Pride 🏳️‍🌈, Trans Pride 🏳️‍⚧️, Christmas 🎄, Halloween 🎃, Red ❤️, Blue 💙, Green 💚, and Gray 🩶. Themes are saved with your settings and apply immediately.

Tips and Starting Points

• Leave steps empty deliberately — rests are just as musical as notes, and are a quick way to add syncopation or breathing room to a pattern.
• Try the unusual Rate subdivisions (the 1/6, 1/10, 1/12, 1/18, 1/21, and 1/24 families) for polymetric or generative-feeling arps that don't lock to a simple grid.
• Build a few short patterns and turn on Pattern Chaining with Random Order for a sequence that keeps evolving instead of looping predictably.
• Long-press a pattern tab to Copy it, then long-press another tab to Paste — faster than redrawing a pattern from scratch.
• Use the Variety knobs sparingly for subtle humanization, or push them high for glitchy, randomized textures.
• Double-tap Shift or Swing any time you want to instantly snap back to 0.
• Save a preset before heavily editing a pattern you like, so you can always get back to it.
• Route Keboard into Kebarp with Mono mode and Latch on: tap one key to lock in a root note and let Kebarp's arpeggiator run completely hands-free, then tap another key to re-root it instantly.

Troubleshooting

• No sound in the standalone app: confirm you have a working output — either enable Internal Synth (Settings → Internal Synth) and raise its Volume, or make sure MIDI Out is routed to an instrument via Core MIDI or the "Kebarp Out" virtual port. Also confirm playback is actually running and that your MIDI source is on the configured MIDI In Channel.
• No sound with the AUv3 plugin: Kebarp is a MIDI effect, not an instrument. Make sure an instrument plugin is placed after it in your host's signal chain and is receiving Kebarp's MIDI output.
• Nothing happens when I play a note: check that your controller or host track is sending on the same MIDI In Channel configured in Settings, and that you're actually holding a note down (Kebarp only sequences while at least one note is held).
• Notes seem to be missing from the pattern: notes that fall outside the current scale or octave range are automatically cleared to rests whenever you change Scale, Min Oct, or Max Oct — widen the octave range or recheck the scale if steps you drew have disappeared.
• Stuck notes: use Settings → MIDI Panic (standalone app) to force a note-off across every note on the MIDI Out channel.
• Sequence doesn't restart when I play a new note: check the Retrigger switch in Settings → Arpeggiator.
• Remote pattern switching isn't working: confirm the CC number and channel your controller/host is sending match Settings → MIDI Settings → Patterns CC# and MIDI In Channel, and that the CC value is greater than 0.
• Pattern Chaining isn't advancing: confirm Pattern Chaining is enabled, that you have more than one pattern, and that the pattern has completed its full Repeat Count of loops.
• Scale keeps changing unexpectedly: Kebarp responds to MIDI Program Change 69 as a scale-sync signal (from the BrainBud companion app) on any MIDI channel by default — check whether another device or app on your MIDI setup is sending Program Change 69.
• User presets aren't syncing across devices: preset sync relies on iCloud being available to the app; without it, user presets stay local to the device that saved them. Factory presets are always available on every device and can't be renamed or deleted.
• Keboard doesn't seem to hold a note for Kebarp: make sure Latch is on in Keboard (otherwise a key only sounds while your finger touches it) and that Keboard's MIDI output is actually routed into Kebarp's MIDI input in your host. If notes aren't coming through at all while Host Sync is on, remember it withholds notes until the host transport is playing.

Links

• Kebarp Website
• Kebarp on the App Store
• All Cem Olcay Apps