Patch Cables

Patch cables join jacks: the round sockets on your Front Panel, on the panels of your modules and on a Rack Canvas. You plug them in, move them and pull them out by hand while the sound keeps playing, the way you would on a hardware modular.

A patch cable makes a real graph connection between two jacks. The graph and the panel show the same connection, and the project saves it with the rest of the patch.

This Rack Canvas example uses the same output-to-input cable gesture as ordinary panel jacks.

Three things to know

• You handle a cable by its jacks, never by its middle. The cable itself does not react to the mouse, so it never gets in the way of the knobs it lies across.
• An output feeds as many cables as you like. An input takes one, unless you turn on Multiple Cables for it. Plug a new cable into an input that already has one, and the new cable takes its place.
• Cables are drawn faint until you point at a jack, so the controls under them stay easy to read.

Quick reference

To	Do this
Plug in a cable	Drag from a Jack Out to a Jack In. You can also start from an empty Jack In and drag to a Jack Out
Send one output to several inputs	Drag from the same Jack Out once for each input
Replace the cable in an input	Let the new cable go on that input
Move a cable to another input	Drag from the input it is plugged into, and let go on the other input
Pull out a cable	Drag it out of its input, and let go away from the jacks
Pull out one cable, or all of them	Right-click the jack and choose the connection by name, or Disconnect All
Plug several cables into one input	Turn on Multiple Cables for that Jack In (Audio and CV)
Change your mind in the middle of a drag	Let go where you started
See where the cables of a jack go	Point at the jack
Undo a change to the cables	Ctrl+Z (Cmd+Z on Mac)

On the Front Panel, the panel's own jacks take cables while the panel is locked, and the jacks on a Rack Canvas at any time. See Where you can patch.

Jacks

Two nodes make the jacks. Both are in the Widgets category of the Node Browser:

Node	On the panel	In the graph
Jack Out	A cable leaves from it	Wire into its In pin what the jack should offer
Jack In	A cable arrives at it	Wire its Out pin to what should receive the signal

Think of a jack as a hole through the panel. The signal goes from your patch into a Jack Out, along the cable, out of a Jack In and back into your patch.

Build a pair of jacks

Use a patch with an LFO already controlling a compatible CV/hybrid parameter. Insert the jacks into that known working route:

1. Add Jack Out and Jack In, and set Type = CV on both.
2. Connect the LFO output to Jack Out — In. Connect Jack In — Out to the destination that the LFO previously controlled.
3. Right-click each jack's header → Add to Front Panel and arrange them on the unlocked panel.
4. Lock the panel, then drag the output socket to the input socket. The modulation route is complete again.
5. Drag the cable from its input socket and release it over empty space to unplug it. Use Undo to reconnect it.

A jack passes the signal through; it does not scale it. If you use an LFO to move Filter's frequency, map its range to suitable Hz values before the jack. A raw 0–1 signal is not a 20–20000 Hz sweep.

Concept diagram: In and Out on the graph describe the signal entering or leaving each jack node. On the panel, a cable leaves Jack Out and arrives at Jack In.

To put a jack on the Front Panel, right-click its node header and choose Add to Front Panel, the same as any widget. Rack Modules usually come with their jacks already on their panels.

What a jack carries

Every jack has a Type: Audio, CV, MIDI or Data. You set it on the node or in the Inspector.

• A cable only joins two jacks of the same type, so audio never ends up in a MIDI input by accident.
• When you change the Type of a jack, the cables that no longer fit are pulled out.
• The rules of the graph still apply. A cable is refused wherever a wire would be, for example when it would make a feedback loop.

Normalled CV inputs

A Jack In set to CV can be normalled, like the inputs of many hardware modules. Turn on Normalled CV in the Inspector, and while nothing is plugged into the jack, it sends the Normal value instead of silence. Plug a cable in and the cable takes over. Pull it out and the Normal value is back.

While Normalled CV is on, Normal is also a pin on the node, so your patch can set it, for example from a knob.

Knowing when a cable is plugged in

Every jack has a Connected output, on the right of its Appearance row. It sends true when a cable is plugged into the socket and false when the last one comes out, so the patch can act on it: open a gate only while something is patched, or quiet a control that nothing feeds. It follows cables that cross modules too.

Colours and look

A cable takes its colour from the Jack Out it leaves. In the Appearance section of the Inspector, every jack has a cable colour for each type: Cable Colour Audio, Cable Colour CV, Cable Colour MIDI and Cable Colour Data. All four start unset, which means the theme's colour for that kind of wire, so a CV cable is the same colour as a CV wire in the graph. To colour your cables, set them on the Jack Outs: on a Jack In they only colour a cable while you drag it out from there.

Cable Alpha on the Jack Out fades its cables from 100% down to 0%, in addition to the alpha of their colour. Connection Alpha sets the round connected point on each jack separately. For invisible cables with visible endpoints, set Cable Alpha to 0% and leave Connection Alpha at 100% on both ends. Hover still highlights the connected points, and you can move or unplug the connection as usual. These settings save with the project and copy with Appearance.

To fade every cable at once instead of one Jack Out at a time, the Front Panel and each Rack Canvas have a Cable Alpha of their own. It works on top of the Jack Out's: at 50% on the panel, a Jack Out at 50% gives cables at 25%. See Cable Alpha for a whole panel or rack.

The ring around the hole wears the theme's colour for the jack's type until you set Ring Colour yourself. The body, the ring, the hole and its size can all be changed, the hole can show a picture of your own, and the caption can say anything or nothing. Every setting is in the Jack In and Jack Out reference.

Plugging cables in

Drag from a Jack Out and let go on a Jack In. The cable is plugged in the moment you let go.

• While you drag, the end of the cable jumps into the jack under the mouse when that jack can take it. If it does not jump in, letting go there does nothing: the jack is of another type, the two jacks are already joined, or the graph refuses the connection, for example because it would make a feedback loop.
• An output feeds as many cables as you like. Drag from the same Jack Out again for each one.
• You can also start from an empty Jack In and drag to a Jack Out.
• Letting go away from the jacks, or back on the jack you started from, plugs nothing in.

Let go on the control

You do not have to find a control's jack first. Let a cable go on a knob, a list or a switch that has a CV jack of its own, and the cable is plugged into that jack. While you drag over such a control it lights up, and the end of the cable jumps to the jack it will end in.

This works for a control whose jack feeds it directly, such as a knob with Modulation on whose Mod comes from a Jack In, and for a list or a switch whose jack is normalled to it.

Stereo cables

Turn on Stereo Pair for two jacks whose names end in L and R, such as Out L and Out R. Then one cable does the work of two: plug Out L into an In L that is also a Stereo Pair, and Out R is plugged into In R as well. Pull either cable out and both come out. A cable from an L jack to an R jack is left alone, since crossing them is something you meant.

A jack that the graph feeds

A jack can also get its signal from a wire in the graph, into the pin it shows on its module. The panel draws no cable for that wire, since there is no jack at its other end, so the jack shows a plug on its own. A jack with a plug and no cable is being fed, or read, from the graph.

An input takes one cable

Each input holds one cable, as on a hardware modular. Let a new cable go on an input that already has one, and the new cable takes its place: the old one is pulled out, in the same step.

While you drag over a busy input, its cable is drawn solid, so you can see which cable letting go there would replace.

To feed one input from several outputs, turn on Multiple Cables for it (see below), or mix them before the jack: a mixer module on a rack, or in your patch a Sig Add for audio or a MIDI Merge for MIDI.

Projects from before MNodes 1.1.3

Before 1.1.3 an input could hold several cables. A project saved like that keeps them all. Clicking such an input opens the menu to pull out one of them or all, and a new cable let go on it replaces all of them, unless you turn on Multiple Cables.

Several cables in one input

Select a Jack In set to Audio or CV and turn on Multiple Cables in the Inspector. That input keeps every cable you plug into it and hears them added together: a new cable joins the others instead of replacing them. MIDI and Data jacks always take one cable.

Clicking an input that holds several cables does not pick one up, since it cannot know which one you mean. It opens a menu that names each connection after the jack at its other end: choose one to pull it out, or Disconnect All.

Moving and removing cables

A cable is always handled by its jacks:

• To move a cable, drag from the input it is plugged into. The cable comes with the mouse while its other end stays in its output. Let go on another input and the cable is plugged in there.
• To pull a cable out, drag it out of its input the same way and let go anywhere away from the jacks.
• To leave it as it was, let go back on the same input. Nothing changes, and nothing goes into the undo history.
• Let go on a jack that will not take it, and the cable goes back where it was.
• To pull out one cable, or every cable of a jack, right-click the jack. The menu names each connection after the jack at its other end, so you can pull out just that one. On a jack with several cables, such as an output feeding three inputs, Disconnect All pulls them all out in one step.

The middle of a cable does not react to the mouse at all. A press on a cable goes to whatever is under it, so the knobs and sliders a cable lies across keep working.

Gesture diagram: start at the connected input. Release on another compatible input to move the connection, or on empty space to remove it.

Undo

Every change to the cables is one step of Undo (Ctrl+Z, Cmd+Z on Mac):

• plugging a cable in, or pulling one out,
• moving a cable to another input,
• a new cable taking the place of an old one: one Undo brings the old cable back,
• the two cables of a Stereo Pair, plugged in or pulled out together: one Undo takes back both,
• Disconnect on a jack with several cables: one Undo plugs them all back in.

Perform has no Undo of its own. There, the Undo button of a Rack Canvas takes back the last module or cable change.

Seeing the cables

Cables are drawn faint, so the controls under them stay easy to read. They are drawn solid when they belong to:

• the jack under the mouse, so pointing at a jack shows at a glance where its cables go,
• the jack you started a drag from,
• the jack a dragged cable is over, which shows what letting go there would replace.

The cable you are dragging is always drawn, and turns fully solid when it is over a jack that can take it. A small plug at each end shows where a cable is plugged in.

Try it on the example above: point at a connected socket and follow the highlighted cable to its other end. Move back to a knob; the cable becomes faint and the knob remains operable beneath it.

Cable Alpha for a whole panel or rack

If the cables cover too much of what is under them, make them all fainter in one place, the way you set cable opacity in VCV Rack:

• Front Panel: unlock the panel, right-click an empty part of it, and choose a value under Cable Alpha, from 0% to 100%.
• Rack Canvas: select the rack and set Cable Alpha in the Appearance section of the Inspector, or use Cables beside the rack's zoom control: drag across it, or turn the wheel over it, and double-click it to go back to 100% (see Looking around). It is for the cables that leave the jacks of the rack's modules, in the graph and on the Front Panel, in place of the Front Panel's.

Both start at 100%, which looks exactly as before, and both save with the project. They fade the cables only, not the plugs at their ends, and cables still turn more solid when you point at a jack. At 0% the cables are hidden and the plugs show where they are plugged in. A cable follows the Cable Alpha of the place its Jack Out is on, the way it takes its colour from its Jack Out: a cable from a module on a rack to a jack on the panel follows the rack's.

Where you can patch

Where	When you can plug cables
Front Panel	While the panel is locked (the padlock in its toolbar), and always in Perform
A module's panel	The same as the Front Panel
Rack Canvas	At any time: on its node in the graph, and on the Front Panel even while the panel is unlocked
Graph	At any time

While the Front Panel is unlocked, you are laying it out: a click on one of its jacks selects it and a drag moves it, like any other widget. Lock the panel to plug cables into those jacks, or patch in the graph.

The jacks on a Rack Canvas are the exception. The rack itself is selected, moved and resized by the band along its edges, so its modules' jacks take cables while the panel is unlocked too, and a cable started there can go into any jack on the panel.

Both ends of a cable you plug by hand have to be on the same surface: two jacks on the Front Panel, or two jacks in the graph. Once plugged, the cable shows wherever both of its jacks can be seen.

Patch cables in the graph

In the graph, the jacks on the panels of the modules drawn in their nodes take cables exactly as they do on the Front Panel, and so do the jacks of Jack In and Jack Out nodes.

• Cables are drawn over the nodes and the wires, and follow the nodes when you move them.
• A click on a cable goes to what is under it, so on the empty canvas it still starts a selection box.
• Each jack node also has a Cable pin. Wiring the Cable pin of a Jack Out to the Cable pin of a Jack In in the graph is the same as plugging a cable between them. The graph does not draw a wire for it: the cable is drawn from jack to jack.
• The wiring shortcuts of the graph, such as Ctrl to drag several wires or Alt to keep a wire on its source, are for wires, not for patch cables.
• A wire can go to a control too. Drag a wire from the output of any node and let it go on a knob of a module's panel: it goes into that knob's CV jack, and the knob lights up while the wire is over it. If the module sits in a Rack Canvas, its way out is made for you, as for a patch cable. Let a wire go on a row of a node, such as a slider, and it is connected to that row's input pin.
• Wires and cables mix. A wire dragged from a node's output can be let go on a module's Jack In, and one dragged from a node's input on a Jack Out. The other way round, a patch cable dragged from a jack can be let go on a node's pin, or on the row of a setting: a Jack Out goes into an input, a Jack In takes an output. The pin or the jack lights up while the cable is over it. One Undo takes it back.
• The wire goes where you plugged it. A wire between a node and a jack is drawn to the jack itself, on the module's panel, and its end jumps to the jack while you drag it there. The module gets no new pin on its node for it: the way out it needs is kept off the node, in a Rack Canvas too. On a Rack Module whose jacks come with pins of their own, such as the MNodes Elements modules, the pin of the jack you plug into goes off the node the same way, and every wire on it is drawn to the jack; a pin that also leads somewhere else inside the module stays. If the module's panel is not showing, as when the node is made compact, the wire goes to the edge of the node instead. Wires you connected to a module's pins before work and look as they did until you plug a wire into that jack. When the pointer is on the jack itself, the wire goes to the jack even if a pin of the module is close by.

Cables between modules

The two jacks of a cable do not have to be in the same module. Plug a cable from a jack inside one module to a jack inside another, or to a jack on your Front Panel, and MNodes makes the way through for you. Inside each module the cable has to leave, it adds an input or output port wired to the jack, with a name that starts with Jack In or Jack Out, and the module gets the matching pin on its node. A Rack Canvas keeps these pins off its node, and so does any module for a port made by a wire let go on one of its jacks.

These ports stay when you pull the cable out, so plugging it back in costs nothing. Undo takes back the cable, not the port.

Cables on a Rack Canvas

On a Rack Canvas, a cable is drawn only as far as the rack shows it. Scroll a module out of view and its cables go out of view with it, and a cable coming from outside the rack meets the rack's edge. Everything about patching on a rack is in Rack Canvas.

Presets and States

Cables are part of your project, so they are saved and opened with it.

A States node and a Preset Manager preset also remember which jacks are joined. Recalling a state or a preset plugs in and pulls out cables to match. Morphing between states moves values only, never cables. A state or a preset saved before MNodes 1.1.3 has no cables in it and leaves them as they are: save it again to include them.

In Perform

Patching works in Perform on the Front Panel, on module panels and on every Rack Canvas, whatever the rack's Add, Move and Remove in Perform switches say.

• Perform has no Undo of its own. A Rack Canvas has an Undo button that takes back module and cable changes.
• Save in the menu under the MNodes logo keeps the cables as they are.

Troubleshooting

I cannot plug a cable on the Front Panel. The panel is unlocked, so a click on one of its jacks selects the widget. Lock the panel with the padlock in its toolbar. The jacks on a Rack Canvas take cables either way.

The cable does not jump into the jack. That jack will not take it: it is of another type, the two jacks are already joined, or the connection would make a feedback loop. Check the Type of both jacks first.

I cannot pick up a cable by its middle. That is on purpose: a cable is handled by its jacks, so it never gets in the way of the controls under it. Drag it from the input it is plugged into.

A cable replaced another one. An input takes one cable, so a new cable let go on a busy input replaces the one it had. Undo brings the old one back. To keep both, turn on Multiple Cables for that input.

Right-click on a jack shows no menu. The jack has no cables plugged in.

A module got new pins after I plugged a cable. They are the ports a cable makes to leave the module. See Cables between modules.

Changing the Type of a jack pulled out its cables. A cable only joins jacks of the same type, so the cables that no longer fit are taken out.

A recalled state did not bring the cables back. It was saved before MNodes 1.1.3. Recall it, plug the cables as you want them and save the state again.