VCV Rack patches in a module? 4ms explains their Meta Module

It’s the prototype that ate Chicago’s Knobcon. 4ms showed their new “Meta Module,” which lets you put patches inside a hardware module. The new module can run compatible VCV Rack patches with full hands-on and CV control. An image went viral, but without all the details. So here’s 4ms to get meta with us and explain exactly what’s going on.

First, the basic module itself:

  • 12 knobs
  • 8 audio or CV outputs (configurable)
  • 6 audio or CV inputs
  • 2 gate inputs
  • 1 USB MIDI connection (USB host – meaning you can add a USB MIDI controller)
  • Cortex A-7 with 512MB of RAM, compatible with a range of VCV modules including 4ms, Befaco, HetrickCV, Nonlinear Circuit, and clones of the Mutable instruments range

I mean, holy crap. You can’t just run any desktop modular patch – you need to use a compatible subset of Rack modules, and you’ll want to tailor this to the capabilities of this embedded module. But this is still a massive development.

4ms provided CDM with this image:

sneak preview front

4ms has been working on this for three years, but wasn’t quite yet planning to launch this publicly until something like early 2024. Of course, the moment something like this is out in the public, it gets attention – enough in this case to steal the show at Chicago’s Knobcon modular and synth gathering. (And this wasn’t even the only VCV Rack announcement at the expo – Kilpatrick made a series of controller modules for VCV Rack, too. More on that separately.)

There’s a lot to wrapping your head around this concept, so I asked Dan Green from 4ms to explain to us what this is, and 4ms wrote up this description.

The Meta Module is an all-purpose module that lets you patch together various virtual modules to create a “Meta” module.

It’s a macro controller for a custom patch that you create.
It’s a hardware player for VCV Rack patches.
It’s a preset manager.
It’s a versatile utility module that lets you save and recall common functions that you re-use from patch to patch, so you can focus on the more interesting parts of your music.
It’s a DSP development platform.

Patches are typically created on the computer using VCV Rack and then transferred to the Meta Module over USB, SD Card, or WiFi. In case you don’t have a computer handy, you can create and modify patches using the Meta Module itself. The Meta Module can run hundreds of virtual modules and store/recall thousands of patch files.

There are 12 knobs, 8 audio or CV outputs, 1 USB MIDI jack, 6 audio/CV inputs, and 2 gate inputs, all of which can be mapped to any of the virtual knobs and jacks within the patch. You can map a physical knob to multiple virtual knobs and assign a different response range for each knob (including inverting the motion).
The audio/CV jacks are DC-coupled and run at 48kHz, 24bit, and can be mapped to any of the jacks in the patch. You can plug a MIDI controller into the USB jack to control knobs and jacks.

Computational power: It uses a dual-core Cortex-A7 running at 800Mhz, with 512MB of fast DDR3 RAM. It runs bare-metal without an OS, so startup time and latency are blazingly fast. It can handle somewhat complex patches, but of course, there are limits. For example, we recently ran a Meta Module patch with four physical-model Djembe modules, stereo reverb, six clock dividers/multipliers, some FX, and a mixer, and had plenty of processing headroom.

We are still adding new modules. The 4ms modules will be available as well as Befaco’s modules and some Mutuable Instruments clones. We’re adding the HetrickCV and Nonlinear Circuit modules now, and more are planned. If you are a developer, running your own VCV Rack Modules or custom DSP code on the Meta Module is fairly easy.

Utility functions and reuse

I was curious about Dan’s comment that you could “reuse” common materials, so he elaborated on that:

Depending on your patching style, you might have some utility modules that you often connect in the same way in most/all of your real-world patches. Besides all the other uses for the Meta Module (i.e. having it play a full-blown patch), one handy thing is to have it take the place of a bunch of boring utility modules (and all the patch cables between them and precise knob positions, etc).

For instance, maybe you often make clock-based patches, so you always have a main clock module splitting off into several clock dividers which trigger envelopes, and you also have all the reset jacks normalized together. You can do this on the Meta Module. So that’s a handful of modules and a dozen or so patch cables you don’t have to worry about every time you patch.

Or maybe you like to use stereo animation in your patches so you often find yourself splitting your envelopes into two VCAs with one side being inverted and shifted. Or maybe you roll your own polyphony and have multiple VCOs, each one patched into a VCA + VCF, with an ADSR driving them, and all of the outputs mixed together.

You could create all of these patches and load them onto the Meta Module, assign inputs and outputs and knobs, and then recall any of them whenever you need it in a real-world patch. The virtual patch you make out of virtual modules will function like a real-world module that you designed and customized to fit your patching style.

It’s just one more way you can use the Meta Module.

That really illustrates why this is useful. And it also will make more sense to a lot of us than the various scattered solutions for custom operations like this – some of which squeeze features almost at random into complicated alternate firmwares or weird knob-push combos or require learning an entirely new programming language. I have to agree that this is a lot easier.

It should also answer the “why would I want to run a modular inside a modular” kneejerk reaction you got from a lot of people. I wouldn’t worry too much about that, though – I think folks just got a bit overwhelmed by the amount of power here. Me, I like overwhelming power. (Cue evil laugh.)

Patch editing on the module, checking parameter mappings

Since is has a display, does that assist with telling which knob is mapped to each function and so on?

Yes, there are several views to see what knobs and jacks are mapped, depending if you are looking at the overall patch, or just one module, or just a group of knobs. We’ve spent a ton of energy on the UI, and are still developing it (hence, this is truly a “preview”), but to everyone who has tested them so far, the feedback is that it’s pretty intuitive. The knobs are given a color (red, yellow, blue, pink, orange, green) and there is a large and small knob for each color. You also can create “Knob Sets”, or groups of knob mappings, and quickly switch between them (like, if you had a patch with eight oscillators, you could create a knob set for each one). This is great if you need more than 12 knobs mapped and don’t want to use MIDI.

You also can make patch notes and give mapped knobs custom names, so there are a lot of options.

And what do they mean when they say you can edit on the module (which sounds pretty daft)? Is that a touchscreen or something? Dan answers:

Not a touch-screen!

Patching typically starts on the computer, using VCV Rack to create a patch and then saving it to the Meta Module.

However, you don’t NEED a computer. You can patch virtual cables, turn virtual knobs, change knob mappings, and even add/remove modules from within the Meta Module. While it’s not going to be anyone’s preferred method to make patches, it’s reassuring to know that if you do need to make a last minute change to a patch, or if you just want to play with some ideas on a long flight or train ride, you can do it without needing a computer.

Yeah, count me in on the last-minute changes side of this. I can’t imagine wanting to patch on the hardware but I can absolutely imagine suddenly needing a change and not being able to get back to the computer to make it.


The company that got everyone’s attention online was Befaco, who also make a kind of meta-module in Lich, which is based on a the Rebel Technology OWL platform. I love that tool – I’ve run my own Pd patches on it. But the absence of a screen means you have to memorize whatever you’ve loaded onboard, down to which parameter does what.

Not so the Meta Module. This really is a full-blown player with screen, so you can see your patch and not lose track of your work.

Manu from Befaco also checked in from Chicago! They describe the process as stunningly easy: “you make your patches around the 4ms module, hit export and – boom!” he says. “You get the patch ready for the module!”

Befaco’s VCV Rack modules will all be compatible from day one.

Watch this space

I’m definitely excited to track this one. For some, the controllers + computer option will be better for running elaborate patches – since then you get full module compatibility and all the power (and storage) of your laptop machine. But that doesn’t make this in any way desirable. And, heck, you could combine the two.

So it’s not entirely fair to start quoting the Xzibit meme. (“Yo dawg, I hear you like patching modular so I put a modular in your…” You know.)

Will that stop me from closing out this story by watching some classic Pimp My Ride? I mean, what did you expect? (Side note – maybe we should do this to people’s live rigs, like, as a reality TV concept. No?)

Source link

Share this post