Intech Studio Grid

Could Intech Studio’s ingenious modular system help you build your perfect MIDI controller?

How often have you been on the lookout for the perfect MIDI controller only to find that you inevitably have to compromise? Either it doesn’t have enough knobs, or far too many, or if only the sliders were in a different place. Well, Grid from Intech Studio offers an interlocking system of MIDI control modules that’s completely configurable. Do you want more sliders? Snap‑on another bunch of four. Do you want more encoders over on the left? No problem, here’s a bank of 16...

There are currently five modules in the Grid system and more are in the pipeline. Can you find the perfect custom MIDI controller within these deeply dark and seriously smart modules?

Hardware

The modules feel substantial in the hand. They are solid, slimline squares of hard matte‑black plastic festooned with knobs, encoders, sliders or buttons, depending on the unit. There’s a pair of four‑pronged spring‑loaded pogo pins on each side, and on either edge is a magnet. The magnets snap the modules together while the pogo pins match up with those on another module to pass power and data. You can snap them together in any orientation so that sliders become crossfaders, or the LED for an encoder is below it rather than above it. The system knows which way up everything is and copes with any change, although the USB‑C port on one side could be called the top, and the Mode button on the opposite side could reasonably be seen as the bottom; the controls appear to be orientated to reflect this.

As you construct your controller, the RGB LEDs flash and glow as connections are forged and understandings are come to between modules. You only need a single USB‑C connection to provide power and data to the whole Grid and it doesn’t matter which one you connect it to.

The encoders feel nice and solid; they turn with detents and are clickable when pushed.

The encoders feel nice and solid; they turn with detents and are clickable when pushed. The knobs are smooth, with a good amount of resistance and feel slightly more solid in place than the encoders. The sliders feel all right, and I like the very fingerable fader caps. Two of them on one of the review modules dragged a little bit on the front panel, although it’s hard to know if this was the fader cap or the edge. The buttons are perfectly fine and buttony. Each individual control has an LED, and for each element that has a maximum and minimum, they increase/decrease in brightness as you move from one extreme to another. The default is a rather pleasing blue, but you also get orange, green and purple to cover all four modes.

Unattached: clockwise from top left, the PO16, EN16, EF44, PBF4 and BU16. Each Grid module has a footprint of 106 x 106mm.

The five modules on review here represent the current product line. There’s the PO16, which has a 4x4 grid of 16 'potmeters' or potentiometers, and the EN16, which is the same but with endless encoders. There’s a 16‑button module called the BU16. The perhaps more interesting two have some combinations: the EF44 has four encoders and four long faders, whereas the PBF4 has four pots, four sliders and four buttons. One small irritation is that the name of the device isn’t written anywhere on the hardware. Of course, it only takes a moment to work it out, but as I come across them referred in the documentation, I’m forever having to stop and think about it.

On the whole, the Intech Studio Grid is gorgeous. Superbly clean lines, intensely dark controls and not‑too‑bright LEDs. I found myself endlessly rearranging them partly to enjoy the flashing LEDs of reconnection and partly because I could. And that’s the point: they don’t have to take on a permanent configuration. You can arrange and rearrange them to fit the device you’re controlling. And you probably wouldn’t have one of each as I have here; you’re more likely to choose the ones that are going to fulfil your own requirements.

I found myself endlessly rearranging them partly to enjoy the flashing LEDs of reconnection and partly because I could. And that’s the point: they don’t have to take on a permanent configuration.

First Play

The online documentation is good, and there’s plenty of it, although it could be a little bit more idiot‑proof. Being a Windows user, I have an expectation of drivers and installers, and there’s no mention of them on the Getting Started page. Am I supposed to believe that it just works? Well, funnily enough, it does, but it would be nice to be told that it will, to save me digging around for an installer. However, after you’ve had a root around, you will find there’s an editor and a firmware updater, and these would benefit from being displayed really large on the first page so that I can confirm that the Grid is indeed working correctly before I try controlling things.

I wanted to see how easy it would be to get going intuitively. So, without any reference to the manual or any editing software, I opened up Cherry Audio’s CA2600 and hit the MIDI Learn button. Every control mapped with a joyful ease. Except for the buttons which believed themselves to be notes and ones that didn’t latch. So they could change the state of some of the 2600’s buttons but not move switches from one setting to another.

Once mapped, I could take the modules apart and rearrange them without losing the mapping. Once the connection was re‑established, it all continued to work perfectly. Switching modes with the little button didn’t seem to achieve anything at this point past a change in LED colour. I assume it will provide you with different configurations or mappings, but as far as CA2600 is concerned, it’s the same CCs regardless of what mode you’re in. This will bear some further investigation.

Simply as a MIDI controller, the Grid is a lovely thing. The modular nature proved its worth to me in how I can build an interface that best reflects what I’m trying to control. It makes you wonder how that versatility stacks up against the usefulness of muscle memory on a fixed controller. But versatility is the key to the Grid, and that’s definitely what you find as you dig deeper into it.

Once mapped, I could take the modules apart and rearrange them without losing the mapping. Once the connection was re‑established, it all continued to work perfectly.

Grid Editor

All the magic happens in the Grid Editor software for macOS, Linux or Windows. The Editor looks really nice and instantly pointed out the out‑of‑date firmware and directed me to update. This is relatively harmless and must be done for each module independently. Your layout is reflected in the Editor’s main window, down to the position of each knob and slider. As you rearrange your physical Grid, it all updates in the Editor very smartly. Each module has four pages into which you can build, save and load configurations. When you push the Mode switch on the module, you are moving through the pages. So the idea is that you can design up to four configurations for your module, which can be stored in the device and are then accessible outside the Editor and away from the computer. Intech call these configurations ‘Profiles’.

The Grid Editor software.

Profiles can be anything from MIDI controller numbers to complex coded happenings. The available selection at the moment is small and a bit muddled. Several are specific to certain bits of hardware, and others do things I don’t yet understand. There are a couple of intriguing ones that turn various modules into sequencers or LFOs, and these will need to be explored. The Windows version of the editor has a problem in that you can’t see more than the first line of text in the profile description, or at least not on my machine. So, I didn’t have much information to go on until I found them mirrored on the Profile Cloud web page, where I could get to the text and full description.

The Grid modules are fully programmable using the Lua scripting language. It is object‑orientated and relatively straightforward but also feels like a barrier to configuring your controller if you are not at home with coding.

So, what do we do if we want to change the MIDI channel or controller number on a control? If you move the control then all the scripting information appears on the right. There are a few tabs depending on whether you want to edit the whole module, the initial instructions, the script for the control or the timing of it. For the basic MIDI control profile loaded by default, there are Local actions and MIDI actions displayed for each control. MIDI actions seem like a good place to start, and there’s an entry for MIDI channel and CC parameters — hooray! But they are not specified. However, if we open up the MIDI monitor, we can see that the control is clearly mapped to a specific channel and CC number. Instead, we have to refer to the Local Actions where we find that the channel is defined as “(module_position_y()*4+page_current())%16” and the CC number as “(32+module_position_x()*16+self:element_index())%128” — excellent!

I’m not one to shy away from complicated things and, as I mentioned, the online documentation is good and comprehensive, but it’s not exactly an easy read. It does tell you that you can simply put in a channel number and CC number in the MIDI Action box, but only after sifting through a lot of information about variables and numeric relationships. It feels like this could be a lot easier. Why not set up the default profiles with defined parameters so that any idiot could edit them without wading through documentation and tutorials?

Well, it’s because of the versatility angle. I understand from Intech that they use variables rather than static values to keep the modules dynamic. The MIDI channels and controller numbers are defined in reference to their position and orientation in the Grid. This way, you’re never going to have a clash between modules. If you buy two of the same modules and they have static values, then the first thing you’ll need to do is open the Editor and change one of them so that they don’t control the same thing. With the scripting and use of variables, they all work around each other and out of the box, you can map a complex Grid of modules to anything with a MIDI Learn button. So there’s clever stuff going on that’s rubbing up against my desire for static simplicity.

Nevertheless, taking my new ability to change controller numbers into another scenario, I was able to rustle up a couple of profiles covering the Shift‑Control elements on the Dreadbox Nymphes. I could load these up on a single module into separate pages and switch between then with the Mode button. That’s exactly the sort of functionality I’d expect from a decent MIDI controller, and once you break through the scripting barrier, it works brilliantly well.

Doing More With Profiles

There were a couple of profiles that did a good job of showing what’s possible with the scripting. The first one was the 4LFO. It transforms the 16‑encoder (EN16) module into a four‑channel LFO, each one controlled by a row of four encoders. The first one specifies the CC number for mapping the LFO, the next controls the range, the next one does nothing, and the last encoder controls the rate. You click it to turn the LFO on and off. MIDI Learn it to a control in your favourite soft synth, and it’s brilliant. But it’s also configured strangely, or at least to my mind. Each LFO is on the same CC but a different MIDI channel. So, in a software synth that doesn’t care about MIDI channels, all four LFOs map to the same control. It depends on the software though; Bitwig Studio was completely fine about mapping all four LFOs to whatever I wanted. For a hardware synth, you would (normally) control it on a single MIDI channel, so I found that I could only use one of the LFOs and would need to specify the CC number of the parameter I wanted to modulate.

That sounded like the sort of thing I should be able to edit. So I opened the Editor and clicked on the various elements, but I was darned if I could find any reference to MIDI Actions or any recognisable fields. Just lots of blocks of code. I was left feeling that there are bags of potential here that are tantalisingly out of my reach. Talking to Intech, they were able to rustle me up a version of the LFO that had a field where I could specify the CC number, which again makes me feel like this is only awesome in the right pair of hands.

Another profile I liked was the Gated Step Sequencer. This takes over the PFB4 (pot‑fader‑button x4) module and gives you four steps going left to right with the knobs providing the pitch, the faders setting the number of repeating gates and the buttons setting three levels of velocity. On a second page, you could also set the gate length for each step. It’s really rather neat.

Once you start putting these things together you end up with a very powerful setup: a very playable four‑step sequencer, a bank of LFOs mapped to something useful, fader controls mapped to waveform levels, a bank of 16 knobs for all sorts of control and 16 buttons that I didn’t quite know what to do with.

The essence of the profiles is that it’s a coder’s dream. If you know a bit of programming, you could make these things do pretty much anything. But if you’re not, you are a little stuck with regular MIDI control. There’s nothing wrong with MIDI control; it’s exactly what we expected it to be, but you can’t help but feel you’re missing a lot of potential. However, the idea behind the Profile Cloud is that people who know how to do these things can share their profiles with the rest of us. I guess this is early days, but a small selection of interesting things for each module would be appreciated, and it would greatly enhance the new user experience.

The modular nature of these controllers is superb. Mixing and matching, building to your own requirements and then reworking it is a marvellous thing.

Conclusion

My overall experience with the Intech Grid modular controller has been a mix of large swirls of serious hardware satisfaction sprinkled with newbie software frustration.

The modular nature of these controllers is superb. Mixing and matching, building to your own requirements and then reworking it is a marvellous thing. The hardware is decent and roomy, and while they lack any labelling or display, the LEDs do a good job of keeping you informed.

I had some stability issues. Sometimes, the Grid Editor wouldn’t see a module, or it would reset or be seen but not working. Some of that is down to my less‑than‑perfectly flat desk, where connections were not as aligned as they could be. But other issues just seemed to be glitches and the nature of open source software where nothing is entirely finished, and the odd bug is part of the deal.

Tackling the Grid Editor can be a bit bumpy, but there’s a huge amount of power and versatility there for the taking if you’re prepared to dig into the scripting language. I found that once I’d made a couple of profiles specific to my synths, the hardware experience proved its worth. There aren’t very many good examples of what the scripting could offer. I imagine it could be a great generator of modulation, shapes, sequences, and randomisation, but I have no idea how to make those happen. Hopefully, in time, Intech and the open source community of users will come up with some great profiles that can unlock more of the power of these boxes.

I don’t want to get hung up on the scripting, though, because, as a MIDI controller, it’s a beautiful system. And I love how the Knot will let you seamlessly merge it into any setup.