Getting Started

MIDI Setup: Connect your Jupiter-6's MIDI OUT to your computer's MIDI IN, and your computer's MIDI OUT to the Jupiter-6's MIDI IN. Enable MIDI access in your browser when prompted.

Jupiter-6 Key Mode Settings: On the Jupiter-6 panel, set the key mode buttons to match Deep Edit's mode:

• Whole Mode: Press WHOLE on the Jupiter-6. All 6 voices play on one MIDI channel. Only the Upper/Whole panel appears in Deep Edit.
• Split 2-4: Press SPLIT 2-4 on the Jupiter-6 (2 voices lower, 4 voices upper). Both Upper and Lower panels appear in Deep Edit.
• Split 4-2: Press SPLIT 4-2 on the Jupiter-6 (4 voices lower, 2 voices upper). Both Upper and Lower panels appear in Deep Edit.

MIDI Channels: Upper/Whole part uses the MIDI channel selected in Settings. Lower part uses one MIDI channel higher. When both Jupiter-6 and Deep Edit are in split mode, you can treat upper and lower as two different synths on different channels.

Init Function: Click "Init" to send a clean starting patch to the Jupiter-6. This resets all parameters to default values.

Performance Controls

Master Volume: CC 7 - Overall output level for the Jupiter-6.

Balance: CC 8/80 - Controls the balance between Upper and Lower parts in split mode. 0 = all lower, 64 = equal, 127 = all upper.

Master Tune: CC 79 - Global tuning adjustment. May not work on all Jupiter-6 units (check hardware).

Glide: CC 5/62 - Portamento/glide time between notes.

Mod Wheel: CC 1 - Modulation wheel value. Destination is user-assignable via Tauntek settings on the Jupiter-6.

PANIC: All notes off - use if notes get stuck playing.

MIDI Clock: Send timing sync to Jupiter-6 for arpeggiator synchronization.

Init: Sends a clean starting patch to the Jupiter-6, resetting all parameters to default values.

Panel Controls (Synthesis)

Whole Mode: Uses all 6 voices of the Jupiter-6 on a single MIDI channel. Only the Upper/Whole panel is active.

Split Mode: Separate control of Upper (high keys) and Lower (low keys) parts. Split point at C3 (MIDI note 60). In split mode, both Upper and Lower panels are active, each controlling their respective MIDI channel.

Knobs: Click and drag vertically to adjust. Values shown below each knob. All knobs send MIDI CC messages to the Jupiter-6 in real-time.

Sliders: Click and drag vertically for envelope controls (ADSR - Attack, Decay, Sustain, Release). Both ENV-1 and ENV-2 are fully controllable.

Waveform Buttons: Click to toggle waveforms on/off. Red/pink = active, gray = off. The Jupiter-6 can use multiple waveforms simultaneously per VCO.

VCO Section: Control oscillator range (octave), fine tuning, waveforms (Triangle, Saw, Pulse, Square for VCO1; Triangle, Saw, Pulse, Noise for VCO2), pulse width, PWM modulation, VCO mixer, and cross-modulation.

VCF Section: Filter frequency (cutoff), resonance, envelope modulation amount, LFO modulation amount, keyboard tracking, filter mode (LP/HP/BP), and envelope polarity.

VCA Section: Envelope amount and LFO modulation amount for the amplifier.

LFO Section: Rate, delay time, and waveform shape (Triangle, Saw, Square, Random).

Arpeggiator: Mode selection (Off, Up, Down, Up/Down, Random) and range (1-4 octaves). Rate is controlled via MIDI clock or CC 61.

32-Pattern Sequencer

Overview: Deep Edit features a polyphonic step sequencer with 32 patterns arranged in a 4×8 grid (A1-D8). Each pattern can contain up to 64 steps with multiple notes per step.

Pattern Selection: Click any pattern button to load it. The current pattern's notes are displayed in the grid below. Pattern name appears above the grid and can be edited (max 30 characters).

Pattern Chaining: Hold Shift and click pattern buttons to create chains. Patterns play sequentially and loop automatically. Example: Click A1, hold Shift, click A4 creates chain A1→A2→A3→A4. The chain is shown in green.

Transport Controls:

• Play: Starts sequence playback from current position
• Stop: Stops playback
• Record: Enables recording mode. Notes played on external MIDI keyboard are recorded to the current step. Automation recording captures CC changes in real-time.

Step Grid - Adding Notes: Click in a cell to add a single note at that step. Click existing notes to remove them. Mouse entry is monophonic - you can only add one note per click. To create polyphonic sequences (chords), you must record them from an external MIDI keyboard while in Record mode. The currently playing step is highlighted.

Sequence Length: Adjustable from 1-64 steps. The sequence loops at the specified length.

Tempo: Adjustable from 40-300 BPM. Controls playback speed for all sequences.

Per-Pattern Patch Selection: Each pattern can use a different sound source:

• Panel Patch: Uses current panel settings (default)
• Jupiter-6 Memory: Select from Banks A-D (31 locations) - sends Program Change before pattern plays
• Patch Library: Select from your saved patches - sends all CC values before pattern plays

Per-Step Program Changes (AFX Mode): The automation lanes include a "patch" lane that allows you to select different Jupiter-6 Memory locations for each step. This enables AFX-style rapid patch switching within a single pattern. Program Changes are instantaneous, making this perfect for glitchy, evolving sequences. Note: Patch Library patches cannot be used per-step due to their 1-2 second transmission time.

Automation Recording: When recording is active and playback is running, all CC changes from panel knobs, macros, or MIDI controllers are recorded into automation lanes. This allows you to create evolving sequences with filter sweeps, LFO rate changes, and more. Multi-pass recording is supported - first pass always records, subsequent passes only update changed values.

Copy/Paste: Copy a pattern to clipboard, then paste it to another pattern slot. All notes, automation, and patch settings are copied.

Randomize/Clear: Randomize generates random notes. Clear removes all notes and automation from the current pattern.

Split Mode Sequencing: In split mode, Upper and Lower sequencers run independently with separate patterns, allowing complex multi-timbral sequences.

Song Mode

Overview: Song Mode allows you to arrange patterns into complete songs with automated pattern changes and performance control recording. Songs are stored in 4 slots per project.

Recording a Song: Click "Record Song", select a slot, then press Play on the sequencer. Pattern cycles (loops) and pattern changes are both captured as "blocks" with repetition counts. If you stay on one pattern, each time it loops counts as one repetition. Tempo, macro, and panel control changes are also recorded with timestamps. Press Stop to finish recording.

Playing a Song: Click "Play Song", select a slot, then press Play. The sequencer automatically loads patterns according to the song's blocks and applies recorded performance data (tempo, macros, and panel controls) at precise times. A playback display shows:

• Progress Bar: Visual progress through the song with percentage (text changes from green to black as the bar passes over it)
• Song Title: Currently playing song name
• Pattern Names: Currently playing Upper and Lower pattern names
• Position: Current bar:beat / Total bars:beats
• Time: Current time / Total time

Playback Mode Notifications: When you press Play on the sequencer, a notification indicates the active mode:

• Pattern Playback: Normal mode - patterns loop until you manually switch them
• Song Recording: Active after clicking "Record Song" - pattern changes are captured
• Song Mode Playback: Active after clicking "Play Song" - patterns change automatically according to the song

Important: Song Mode only activates when you click "Play Song" or "Record Song" before pressing the sequencer Play button. It's a one-time activation - after playback stops, you return to normal pattern mode. To play a song again, click "Play Song", select the slot, and press Play again.

Looping & Chaining: Enable "Loop Song" to continuously loop the current song. For songs 1-3, check "Play next song after this" to chain songs together - they'll play sequentially. When looping with chained songs, the entire chain loops from the first song.

Editing Songs: Click "Edit Song" to:

• Rename the song
• Add, delete, or reorder blocks
• Change which patterns each block uses - every block has Upper and Lower pattern selections
• Select "No Sequence" for Upper or Lower to play silence on that part while the other part plays
• Patch names are displayed for reference next to each pattern selection
• Adjust how many times each block repeats
• Delete all performance data while keeping pattern sequence

Upper/Lower Pattern Selection: Every song block allows independent Upper and Lower pattern selection. If you're working in Whole mode and only need one sequencer, simply leave the Lower pattern set to "No Sequence". In global Whole mode, the Lower pattern selection is hidden in the song editor since the lower sequencer isn't active. This simplified approach eliminates the need to track mode per-pattern while giving you complete flexibility.

Recording Options: If a slot already contains a song, you can Replace Everything, or Overdub Performance Data (adds new tempo/macro/control changes while keeping existing patterns).

Stop Button Behavior: Pressing Stop during song playback exits Song Mode completely. To play the song again, click "Play Song", select the slot, and press Play.

Manual Override: If you manually change patterns during song playback, Song Mode automatically disengages and continues normal sequencer operation.

Project Integration: All songs are saved in project files with pattern sequences and performance data intact. Use the Songs checkbox in the Save/Load Project dialogs to include or exclude songs.

Patch Library

What is the Patch Library? The Patch Library is Deep Edit's internal storage system for saving your custom patches. It exists only within Deep Edit and is ideal for creating, storing, and organizing your own Jupiter-6 sounds for long-term use.

How It Works: Patch Library patches are stored as sets of MIDI CC values (one for each synthesis parameter). When you recall a patch from the library, Deep Edit sends all CC messages in serial at a rate the Jupiter-6 can accept. This takes approximately 1-2 seconds per patch.

Adding Patches: Create a sound using the panels or generator, then click "Add to Library". You can name the patch, assign a category, add author info, and write notes. Both Upper and Lower panel settings are saved.

Recalling Patches: Click any patch in the library to send it to the Jupiter-6. You can send to Upper, Lower, or Both parts. The patch is immediately transmitted and should be heard within 1-2 seconds.

Organizing: Filter by category or search by name. Sort alphabetically, by category, or by date. Edit patch details by clicking the edit button.

Using in Sequencer: Patch Library patches can be assigned per pattern in the sequencer. Select "Patch Library" as the source, then choose which patch. The patch will be sent when the pattern starts playing. Note: Because transmission takes 1-2 seconds, Library patches cannot be used for per-step patch changes (use Jupiter-6 Memory for that).

Important Distinction - Library vs. Memory Manager:

• Patch Library: Deep Edit's internal storage using CC values. Best for creating your own patches and storing them long-term. Can be used per pattern (but not per step). No hardware interaction required.
• Memory Manager: Controls Jupiter-6's internal memory using Program Changes and SysEx. Best for fast patch switching in sequencer (per pattern OR per step). Requires saving patches to Jupiter-6 hardware first.

Import/Export: Export your entire patch library to a JSON file for backup or sharing. Import libraries from other Deep Edit users. When exporting, all memory dumps are also included.

Project Integration: All patches in your library are automatically saved in project files, ensuring complete session backup.

Recommended Workflow: Create patches using the panels and generator, save them to the Patch Library, test them from the library, then use the Memory Manager to save your favorites to Jupiter-6 hardware for fast access in the sequencer's per-step automation.

Patch Generator

Categories: Choose from 30+ categories including pads, bass types, leads, plucks, drums, FX, and more. Each category produces patches with characteristics appropriate to that sound type.

Patch Seeds: Each category has a starting point patch (seed) that serves as the foundation for generation. Seeds can be evolved using randomization controls to create variations while maintaining the category's character.

Custom Seeds: To use your own patch as a seed: create the desired sound, add it to the library, then choose "Set as Patch Seed" for that category. The system will notify you if replacing an existing seed. Use "Reset Seeds" to restore factory defaults. Individual seeds can be removed in the library.

Randomization Controls: Tick the checkbox for any parameter you want to vary, then move the slider to set the percentage of allowable variation. For example, 50% variation on filter frequency means the generated value can be ±50% from the seed value. Disabled parameters remain fixed at their seed values.

Tuning Tip: Many generated patches simply need tuning/detuning adjustment. Disabling variations for VCO Range and Fine Tune parameters often produces more immediately usable results.

Generation Process: Click "Generate Patch" to create a random patch within constraints. The patch is automatically sent to the Jupiter-6 so you can hear it immediately.

Target Selection: Choose Upper, Lower, or Both to determine where the generated patch is sent. In split mode, you can generate different patches for each part.

Saving Generated Patches: If you like a generated patch, click "Add to Library" to save it for later recall. You can then name it and assign proper categorization.

Memory Manager

Understanding Memory Concepts: The Jupiter-6 stores its patches in internal memory. The Memory Manager provides two ways to access this memory:

1. Jupiter-6 Internal Memory (Program Changes):

• The Jupiter-6 has 31 internal patch storage locations across Banks A-D
• Clicking any bank/number sends a Program Change message to recall that patch instantly
• These can be accessed per pattern in the sequencer OR per step in automation lanes
• Program Changes are instantaneous - perfect for AFX-style per-step patch switching
• You must save patches to Jupiter-6 hardware using the WRITE button before they appear here
• Deep Edit cannot retrieve individual patches from Jupiter-6 memory

2. SysEx Memory Dumps (Complete Backups):

• A SysEx dump is a complete snapshot of all 32 patch locations (Banks A-D) in Jupiter-6 memory
• Deep Edit maintains a library of these complete dumps for backup and restoration
• Each dump can be named, saved as .syx files, and sent back to restore all 32 patches at once
• Dumps are automatically saved in project files for complete session backup
• SysEx format is proprietary - you cannot convert between Patch Library and SysEx as Tauntek has not published the specification

Receiving SysEx Dumps: Click "Receive from Jupiter-6" for instructions. Manual procedure: Press and hold TUNE, then press and release WRITE on the Jupiter-6. The complete memory dump is automatically captured and added to your SysEx dump library.

Loading .syx Files: Load previously saved .syx dump files from disk. They are automatically added to your dump library and can be sent back to the Jupiter-6.

Dump Actions: Each dump in the library has two buttons:

• Send to JP-6: Restores all 32 patches to Jupiter-6 hardware memory
• Save .syx: Exports dump as a .syx file for archival, sharing, or use with other SysEx applications

Rename & Delete: Click any dump's name to rename it. Use the Delete button to remove dumps from the library.

Project Integration: When saving a project, you can choose to include SysEx dumps. When loading a project with dumps, you'll be given the option to send one of them to the Jupiter-6.

Recommended Workflow:

1. Create patches using panels and generator
2. Save favorites to Patch Library for organization and backup
3. Send patches to Jupiter-6 and use hardware WRITE to save to specific memory locations
4. Capture SysEx dump to backup your complete Jupiter-6 memory configuration
5. Use Jupiter-6 Memory (Program Changes) in sequencer for fast per-pattern or per-step patch switching
6. Use Patch Library patches per pattern when slower CC-based switching is acceptable

Important Note: Remember that a Jupiter-6 patch consists of both Upper and Lower sounds. When using the sequencer's per-pattern patch selection, consider whether you need split mode patches or whole mode patches depending on your musical arrangement.

Macro Controls

Overview: Macro Controls provide 8 programmable knobs that can control multiple destinations simultaneously. Each macro can route to up to 8 different parameters anywhere in Deep Edit.

Creating a Macro: Click the "Edit" button below any macro knob to open the Macro Editor. Here you can:

• Name your macro (e.g., "Filter Sweep", "Resonance + Drive")
• Add up to 8 destination parameters from dropdown menus
• Set min/max ranges for each destination (allows inverted control, partial ranges, etc.)
• Remove destinations you no longer need

Using Macros: Turn the macro knob to simultaneously control all assigned destinations. Each destination responds within its configured min/max range. For example, a "Brightness" macro might control filter cutoff (50-127), resonance (0-80), and VCA LFO amount (0-40).

Display Modes: Toggle between knob and slider display using the button below each macro. Both modes function identically.

MIDI Learn Compatible: Macros can be mapped to MIDI controller knobs using MIDI Learn mode, providing a powerful layer of controller customization.

Automation Recording: Macro movements can be recorded into sequencer automation lanes, allowing complex multi-parameter evolution over time.

Project Saving: All macro configurations are saved in project files, preserving your custom control setups.

Example Use Cases:

• Performance Macro: Control filter cutoff, resonance, and LFO rate together for expressive filter sweeps
• Movement Macro: Modulation amount, LFO rate, and PWM for evolving textures
• Character Macro: VCO detune, cross-mod, and pulse width for timbral shifts

MIDI Learn

Overview: MIDI Learn allows you to map any MIDI controller knob, fader, button, or pad to any control in Deep Edit. This provides hands-on tactile control of synthesis parameters, making Deep Edit feel like a hardware synthesizer.

How to Map a Control:

1. Click the 🎛️ MIDI Learn button (turns cyan when active)
2. Click any knob, slider, or control in Deep Edit (status shows "Armed: [control name]")
3. Move a knob/fader on your MIDI controller
4. The control is now mapped! A cyan dot appears on the control

Visual Indicators:

• Cyan dot: Control is mapped and enabled
• Orange dot: Control is mapped but disabled (won't respond to MIDI)

Channel-Specific Mappings: MIDI Learn supports channel-specific mappings, allowing multiple controllers to control different parameters simultaneously on different MIDI channels.

Multi-State Controls: Special handling for buttons, button groups, and dropdowns:

• Dropdowns: CC range automatically divided by number of options (e.g., 3 options = 0-42, 43-84, 85-127)
• Button Groups: CC range divided evenly (e.g., split mode buttons use three ranges)
• Instant Buttons: Trigger on any CC value (Randomize, Clear, etc.)

Graduated Smoothing: MIDI Learn uses intelligent smoothing to prevent jumps when you first touch a controller:

• Large jumps (>40): 80% old value / 20% new value
• Medium jumps (>20): 60% old value / 40% new value
• Small jumps (>10): 40% old value / 60% new value
• Tiny changes (≤10): Direct value (no smoothing needed)

Mappable Controls: All panel knobs (VCO, VCF, VCA, ENV, LFO), envelope sliders, tempo knob, macro controls, performance controls (Volume, Balance, Tune, Glide, Mod Wheel), and most dropdowns can be MIDI learned.

Protected Controls: MIDI ports, MIDI settings checkboxes, channel selection, project controls, help button, MIDI Learn management buttons, split mode buttons (group mapping planned), sequencer transport buttons, and copy/paste buttons are protected from MIDI Learn to prevent accidental mapping. PANIC can be mapped if you want to trigger it from a controller.

Managing Mappings:

• Remapping: Enter MIDI Learn mode, click the control, and move a different controller knob
• Enable/Disable: Toggle individual mappings on/off in the MIDI Learn status panel
• Clear All: Removes all MIDI mappings at once
• Export/Import: Save mapping sets as named JSON files for sharing or backup

Project Integration: MIDI mappings are automatically saved with your project files (.jp6proj) and restored when you load a project, making your controller setups portable.

Tips: For best results, use absolute knobs/faders (not endless encoders) on your controller. Open the browser console (F12) to see detailed MIDI Learn activity.

Project Management

Project Files: Deep Edit projects (.jp6proj) are comprehensive JSON files that contain your complete working session.

Save Project: Click "Save Project" to export your workspace. A dialog allows you to select which items to include:

• Patch Seeds: Custom category starting points for the generator
• Library Patches: All saved patches with names, categories, and parameter data
• Sequences: All 32 patterns with notes, automation, and patch assignments
• SysEx Dumps: Complete Jupiter-6 memory backups in your dump library
• MIDI Learn Mappings: Controller mappings with enable/disable states
• Macro Controls & Global Settings: Macro configurations, tempo, MIDI channels, port selections, clock settings, performance controls

Load Project: Click "Load Project" for a 3-stage workflow:

1. Stage 1: Select which items to load (unchecked items keep their current state)
2. Stage 2: Choose .jp6proj file from disk
3. Stage 3: If project contains SysEx dumps and you chose to load them, select which dump to send to Jupiter-6 (or skip)

Selective Loading: The load dialog allows you to selectively restore only certain aspects of a project. For example, you can load sequences and MIDI mappings while keeping your current patch library.

Sharing Projects: Project files can be shared with other Deep Edit users. They are self-contained and include all data needed to recreate your session, making them perfect for collaboration or distributing complete production templates.

Backup Strategy: Regularly save project files to preserve your work. Projects can be version controlled, stored in cloud services, or backed up to external drives.

Settings & MIDI Configuration

MIDI Ports:

• MIDI Out: Primary output to Jupiter-6 for synthesis control and notes
• MIDI In: Input from Jupiter-6 for SysEx dumps and visual keyboard feedback
• MIDI Controller: Primary controller for MIDI Learn CC mappings
• MIDI Controller (CC): Secondary controller for additional MIDI Learn mappings
• Mirror Output (DAW): Optional second output for DAW integration (see below)

MIDI Channels: Select Upper/Whole and Lower channels. Upper defaults to channel 1, Lower uses one channel higher. Channels are saved in project files.

MIDI Clock:

• Send Clock: Sends MIDI clock to Jupiter-6 for arpeggiator synchronization
• Sync to External Clock: Makes tempo read-only (future feature - full external sync not yet implemented)

DAW Integration (Mirror Output)

Mirror Output Port: Sends a copy of all MIDI data (notes, CC messages, MIDI clock) to a second MIDI output for integration with Digital Audio Workstations.

Use Cases:

• MIDI Recording: Record Deep Edit's output in your DAW as MIDI data
• Clock Master: Use Deep Edit as MIDI clock source for DAW synchronization

Setup: Select a virtual MIDI port (like IAC Driver on Mac or loopMIDI on Windows) as Mirror Output. Configure your DAW to receive from the same port.

Split Mode Audio: For advanced users interested in even deeper integration with modern workflows, the Tauntek Dual Output modification adds separate audio outputs for the Upper and Lower parts of the Jupiter-6. This hardware modification allows you to route each part to separate mixer channels or recording tracks, opening up new possibilities for multi-track recording and live performance.

Jupiter-6 Resources

Tauntek MIDI Modification:
Tauntek Jupiter-6 MIDI Mod Page

Sunshine Jones MIDI CC Cheat Sheet:
Jupiter-6 Tauntek CC Reference

Owner's Manual:
Jupiter-6 Owner's Manual (PDF)

Service Manual:
Jupiter-6 Service Manual (ZIP)

Multi Audio Output Mod:
ModWiggler Forum - Stereo Output Modification

midi.guide Instrument Definitions

Got a Hapax, Pyramid, Droid, or Oxi sequencer? The midi.guide community has created ready-to-use instrument definitions for the Tauntek Jupiter-6 MIDI upgrade.

Visit midi.guide Jupiter-6 Tauntek page for downloadable configs:

Squarp Hapax

Performance groovebox

Squarp Pyramid

Polyphonic MIDI sequencer

Der Mann mit der Maschine Droid

Modular sequencing system

Oxi One

Hardware sequencer & controller

These instrument definitions map Jupiter-6 parameters to your sequencer's controls for hands-on sound design and performance.

Credits

Deep Edit © 2026 DCE Records

Jupiter-6 MIDI Modification by Tauntek

MIDI CC Reference Sheet by Sunshine Jones