The file name without .toml is the profile id. The id uses only a-z, 0-9 and -. For example, the id of arturia-minilab-mk2.toml is arturia-minilab-mk2.

Profiles assume the factory preset of the device.

Supported controllers #

Controller	Profile	Driver	Connection
JamJum JP-Mini	`jamjum-jp-mini.toml`	`jamjum-jp-mini` (built in)	USB and Bluetooth
Arturia MiniLab mkII	`arturia-minilab-mk2.toml`	`palette`	USB

Find the messages of your controller #

Connect the controller to the Mac.
In a clone of the repository, enter this command:
```
devenv shell -- cargo run -- midi-monitor
```
If padmon is installed, you can also enter target/release/padmon midi-monitor. Do not build target/release again for this. The hooks use it.
Write down the names of the input port and the output port of the controller.
Push each pad on each bank. Write down the messages that each pad sends.
Look at the -> part of a line. It shows the pad that a profile already knows.

To listen to one port only, enter this command:

devenv shell -- cargo run -- midi-monitor "<port prefix>"

To find the message that sets a pad color, use the documentation of the vendor or the editor app of the vendor. Then make sure that the message operates on the device.

Write a profile #

The file arturia-minilab-mk2.toml is the example for this section. It starts like this:

name = "Arturia MiniLab mkII"
verified = { by = "flo", date = 2026-09-26 }
driver = "palette"
input_port = "Arturia MiniLab mkII"
output_port = "Arturia MiniLab mkII"
pads = [
  { press = [{ note = 36, channel = 10 }] },
  # ... pads 2 to 8 ...
  { press = [{ cc = 22, channel = 1 }] },
  # ... pads 10 to 16 ...
]

[palette]
message = "F0 00 20 6B 7F 42 02 00 10 {pad} {color} F7"
pad_ids = [0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E, 0x7F]
colors = { off = 0x00, red = 0x01, green = 0x04, yellow = 0x05, blue = 0x10, magenta = 0x11, cyan = 0x14, white = 0x7F }
states = { idle = "green", working = "magenta", waiting = "yellow", background = "blue", reserved = "white" }

Field	Required	Meaning
`name`	Yes	The name of the controller model.
`verified = { by, date }`	Yes	The person who checked the profile on the device, and the date of the check. `date` is a TOML date, for example `2026-09-26`.
`driver`	Yes	`palette`. The driver `jamjum-jp-mini` is only for the JP-Mini.
`priority`	No	A number. The default is 0. padmon tries a profile with a higher number first. The JP-Mini has 1.
`input_port`, `output_port`	Yes, for `palette`	The start of the port name. padmon uses the first port whose name starts with this text. It must not be empty. The `input_port` must not be the start of the `input_port` of a different palette profile. It must not start with `JP-Mini`, because the JP-Mini driver uses these ports.
`pads`	Yes	1 to 16 pads. The position in the list is the pad number: the first entry is pad 1. Each `press` is a list of messages. A message is `{ note, channel }` or `{ cc, channel }`. The channel is 1 to 16. A message can be in one pad only. A `note_on` with velocity 0, a `note_off`, or a `cc` with value 0 is the release of that pad.
`init`	No	A list of hex messages. padmon sends them after it connects. Use `init` only to change a mode of the device. Do not use it to write presets or firmware.
`[palette]` `message`	Yes, for `palette`	The message that sets the color of one pad, as hex bytes. It contains `{pad}` one time and `{color}` one time. It is one MIDI message.
`[palette]` `pad_ids`	Yes, for `palette`	One value for each pad. padmon puts this value in `{pad}`.
`[palette]` `colors`	Yes, for `palette`	Color names and their values, as `name = byte`. padmon puts the value in `{color}`. The list must contain `off`.
`[palette]` `states`	Yes, for `palette`	A color name for each of these states: `idle`, `working`, `waiting`, `background` and `reserved`.

The palette driver makes two states blink:

A reserved pad (a new window) shows its color for 1 second, and then it is off for 1 second.
A waiting pad shows its color for 1.5 seconds, and then it is off for 0.5 seconds. All waiting pads blink at the same time.

The palette driver does not change the brightness, and it does not show the context fill.

Many controllers change the color of a pad while you push it. When you release a pad, padmon sends the color of that pad again.

Examples #

Each profile has one or more [[example]] entries. An example has two fields:

slots: one entry for each pad. An entry is off, reserved, or a state name.
bytes: each message that padmon sends right after it connects. First come the init messages. Then comes one message for each pad, in pad order. A pad that blinks shows its "on" color.

Write hex with two digits for each byte. Put one space between two bytes.

This is a short example for a profile with 3 pads:

[[example]]
slots = ["working", "waiting", "off"]
bytes = ["F0 00 20 6B 7F 42 02 00 10 70 11 F7", "F0 00 20 6B 7F 42 02 00 10 71 05 F7", "F0 00 20 6B 7F 42 02 00 10 72 00 F7"]

cargo test compares each example with the bytes that the driver sends. When a profile is wrong, the test gives the name of the file and the rule.

Pull request checklist #

The profile file and its examples are in this folder.
devenv shell -- cargo test passes.
You checked the profile on the device:
- The pads show the state colors.
- Pushes on each bank show the correct pane.
- A released pad shows its color again.
You filled in verified.
You added the controller to the list of supported controllers in README.md.
For the reviewer: make sure that init does not write presets or firmware.

Controllers that the palette driver cannot drive #

The palette driver cannot drive these controllers:

Controllers that set RGB colors through SysEx.
Controllers that use the note velocity as the color.
Controllers with more than 16 pads.

For these controllers, open an issue. Attach the output of padmon midi-monitor. These controllers need a new driver in Rust.