Update – Create Your Own Minilogue Preset Bank

A lot has happened since my last post about how to make your own preset banks for the Minilogue editor. For one thing, unbeknownst to me, Korg in fact has uploaded the MIDI implementation for the Minilogue. http://www.korg.com/us/support/download/manual/0/544/2890/ I’m not sure how I missed that! In any case, I owe Korg an apology as they obviously did listen to their customers on this issue, and for that I commend them.

The second thing that’s happened is there is now an actual synth editor being actively developed for both Mac and PC, and although I’ve only begun to play with it, it seems to be everything we’ve all been hoping for–a way to create synth patches using a computer, including the ability to edit the motion sequence data. You can find out more about this project here: http://audio.julieneres.com/product/minilogueEdit

The third thing that’s happened is that, since creating my first post on creating a minilogue preset, I’ve realized that not everyone has the time or inclination to create banks like this by hand. So I created a little command-line utility in Python so others can create presets more easily. Note; you do need to know how to run a Python script from the terminal, and unfortunately, I cannot offer any help with this (otherwise I’d never have time to do anything else), but for those who are interested, you can find it here: https://github.com/tunabee/minilogue-lib2preset It’s designed to run in either Python 2.x or 3.x and doesn’t require any external dependencies. I haven’t had a ton of time to work on it so it’s pretty rough around the edges, but it does work!

Create Your Own Minilogue Preset Bank

First off I’d like to say: Korg, I love you, but you could have been better to all the nice folks who shelled out $500 for your Minilogue 4-voice analog synthesizer. Not only have you not created an easy way for users to create their own shareable preset banks–ones that look professional and will show up in the Preset Data window of your Minilogue librarian, you also have yet to make available to us the SysEx dump format so independent developers could create a fully featured Editor which would allow users to edit sequence data, etc., from the comfort a of a computer screen.

I’ve attempted to contact Korg to get the SysEx format every way I can think of, including Twitter and email. I even sent a tweet to Tatsuya Takahashi in the hope of maybe getting some traction, but with no luck. I don’t blame Tats at all–he’s a busy guy doing amazing work, and he may not be authorized to make the Minilogue’s SysEx implementation available even if he wanted to.

The more immediate disappointment was that the minilogue Sound Librarian doesn’t give users any way to create their own professional-style sets such as the UK Producer Set available from Korg’s website. But I figured out how to do this. It’s not terribly difficult.

  1. Save your presets using File > Save. This will create a bank with the format bank.mnlglib.

  2. It turns out that bank.mnlglib is just a zip file with a couple of files for each preset and some metadata in XML format. Unzip bank.mnlglib.

  3. Use your favorite text editor to create a file called PresetInformation.xml and populate it with the information for your bank. Here’s the PresetInformation.xml file that is in the UK Producer Set file (replace their information with your own):

    <?xml version="1.0" encoding="UTF-8"?>
      <DataID>UK Producer Set</DataID>
      <Name>UK Producer Set</Name>
      <Author>KORG UK</Author>
      <Copyright>KORG Inc.</Copyright>
  4. Your Minilogue bank folder has a file we don’t really need called FavoriteData.fav_data. I haven’t tested to see if this file does anything detrimental, but better safe than sorry.

  5. Create a new .zip file, which has all the original files plus the PresetInformation.xml file you created. Rename the .zip part of the file to .mnlgpreset and import it into the librarian just as you would any of the other banks on Korg’s website (all two of them at the moment).

Have fun!

Drum Synthesis with the Korg MS20

Lately I’ve been getting pretty deep into analog synthesizers. The current setup includes a Korg MS20 Mini, which I’ve quickly fallen in love with. It’s very quirky and fun, although some would probably replace the word quirky with incompatible with standard CV pitch signals and the word fun with frustrating.

The more time I spend with the MS20, the more I realize that this really is a musical instrument. The way it sounds depends completely on who is patching and playing it. For such a simple instrument, it’s incredibly deep. So in order to really master the MS20, I’m working on a series of videos to share some of the patches I’ve come up with. The idea is that in five to ten seconds, you can look at what I’ve done, hear the results, and then create the same sound on your own MS20 (or something in the ballpark–I know these machines have a lot of variation). Here’s the first one.

In this video, the MS20 is sequenced by the Korg SQ-1 analog step-sequencer. I’ve routed the CV signal to the TOTAL input, which is being used along with envelope generator 2 to control the lowpass filter. This allows me to get a sort of kick/snare depending on the CV at the time the gate signal is sent. But for the most part, I think the video speaks for itself.

Why You Should Learn Linux

Tux, the Linux penguin mascot.

I originally wrote this for a class I’m TA-ing, and thought I’d share it here as well! –SL


You probably already know that Linux is a free computer operating system, and that it has a reputation for being difficult to learn. You may not know, however, that Linux is actually only the latest (and most popular) member of a family of operating systems that dates back to the early 70’s. The history is interesting, but I won’t bore you with it here.

In brief, you need to learn Linux because:

  • It powers the web (your website is going to end up on a Linux server)
  • It has powerful (and usually, free) tools to help make software development easier
  • Some of the more involved aspects of web development require spending time on the Linux command-line.

Plus, it really does look great on a resume!

Linux powers the web

So why do you need to know Linux if you want to be a programmer or web developer? Take a look at this page that measures how many web servers use each operating system. At the time of this writing, Windows is used by less than 2% of the servers on the internet. Every other operating system on this list (Red Hat, Debian, Ubuntu, etc) is some version of Linux.

If knowing what is going on with the servers that are powering your clients’ applications isn’t reason enough, consider also that the number of desktop users of Linux is also growing.

The terminal (aka the shell, aka the command line)

When people say, “you should learn Linux”, what they often really mean is, “You should learn to use the command line in Linux and know the basics of the Linux file system,” and this is also what I mean, because Learning (with a capital “l”) Linux takes years and years. But learning the basics of the command line is relatively easy, and if you plan to do any amount of web development, the payoff will be worth the effort.

Now that every operating system (including most distributions of Linux) default to a desktop environment, fewer and fewer people really need to get acquainted with the command line (also known as the shell). When faced with something that looks like this

slebeau@Tiptop-107653 MINGW64 ~

most people feel completely lost (except, of course, for those of you who have used PowerShell or are old enough to have used MS-DOS.

There are powerful command-line-only tools for web developers

What made the original Unix operating system so popular and powerful was how it let you get complex work done by chaining the input and output of different utilities together. For example,

$> ls | more

takes the output of ls (which just lists the files in a directory) and pipes its output to more, which is a program that prints text to the screen one page at a time. That | symbol is called a pipe.

These chains can become pretty complex and hard to read for a beginner. Here’s a bash one-liner to convert some AVI files to MP4 using the command-line version of Handbrake:

$ for INPUT in *.avi ; do echo "${INPUT%.avi}" ; done | xargs -i -P9  HandBrakeCLI -i "{}".avi -o "{}".mp4

You can even create your own small utilities and chain them together to help you get work done as a developer.

You don’t need to be an expert!

You don’t need to understand what’s going on here–I’m not trying to frighten you off, but simply to show the immense power available to you on the command-line.

Imagine you were working on a project that had thousands of files (not uncommon), and you discovered that you needed to rename a function called StevenFunction to BillFunction. The problem is, now that you’ve changed the name of that function, you’ll need to change every instance of StevenFunction in thousands of files. While you could certainly open each file and manually do a search and replace, you could just as easily fix all of those files in one go using a single line of code on the command line. These kinds of one-liners are so common that there are websites dedicated to them so people don’t have to constantly re-invent the wheel.

Linux was primarily designed for power users and programmers, and most distributions of Linux come with a set of powerful tools. Many of thees tools date back to the original Unix mainframe days.

Linux can be kind of dangerous

With great power comes great responsibility. Since Linux will let you literally do anything, you do have to be careful when running code you’ve found online. You need to know at least the very basics of how the terminal works, what rm and chmod do. Just as you can get a ton of work done by typing in one line of commands at the command-line, you could also wipe your entire hard drive by typing in less than ten characters. Still, if you get to grips with the basics and always back up anything important, you should be fine.

You don’t have to replace your current operating system

Virtualbox is a free virtualization package that allows you to run different operating systems in their own virtual file system without having to erase your current operating system. This is a great way to get started learning Linux, because even if you do manage to permanently destroy your Linux environment, the worst that will happen is you will have to delete it and start over with a new virtual file system. Not only that, but you can have as many “boxes” as you want, each running a different operating system.


Say you are a web developer and you develop websites for multiple clients. You have to work on all these sites locally, but you don’t want to have all of these projects sharing the same MySQL server. Besides, these sites all have to be hosted with different companies running different versions of PHP, MySQL, Linux, and Apache.

Vagrant (which uses Virtualbox) allows you to create a virtual local host for each of your clients, each with the same exact (or close) settings as the host server. You can work on each project in its own “sandboxed” environment, meaning that each project will be isolated.

Additionally, Vagrant works well with version control systems like Git and Github, which will allow you to make snapshots of your web projects at different points, and revert back to these earlier snapshots if you mess something up. Version control also makes it easy for multiple people to work on the same project while minimizing conflict issues.

Conclusion and some advice

I was originally going to write specifically about Linux and why it’s good to learn, but in working on this post, I realized there are a lot of Linux-related (but not exclusively Linux-related) things you need to know if you want to be a web developer. The best advice I could give you is to simply download Virtualbox, download a distribution of Linux (I would recommend Ubuntu), and just start finding your way around. If you are on a Mac, you already have a Linux (well, BSD) system of sorts, but you should still download Virtualbox and Ubuntu so you don’t do any permanent damage to your host system.

New Renoise “tool”: Empty KeyBindings.xml

Picture of Renoise's preferences window.

For a long time, I’ve been meaning to update my Renoise keybindings to work better with my MacBook Pro’s keyboard. Eventually, I want to add some Vim-like functionality to Renoise, but that will involve getting my hands dirty with Lua (a language so small that you have to create your own functions just to show the contents of a table, the primary data structure of the language). But for now, I offer you a blank slate for customizing Renoise’s keybindings completely. I really do mean completely: This even clears out key commands for Quit, Preferences, and other commonly accessed menu items. You should really back up your key commands before you load this. You have been warned!


Fun with APIs

I’ve been getting back into the groove lately with my college studies. I literally blazed through the JavaScript modules in two intense, daylong sessions last weekend. I shaved about a month off of the time it will take to complete my studies, and I’m fairly sure I can knock out PHP/MySQL by next week (or the week after that).

I finally feel excited about web development, and a big reason for that is discovering some of the cool API’s out there covering subjects I’m actually interested in. Programming isn’t really an isolated domain; programming is something you do to solve a particular problem in some other domain (music, medicine, astronomy, nutrition, finance, hog farming, etc). The advice I’d give anyone who wants to learn about web development would be, “Find some cool, free API’s, and start playing around with them.” Sure, you still have to learn the boring stuff first, but a spoonful of sugar helps the boring stuff go down, and there is nothing sweeter than working with data in a domain that you actually care about (or, a domain that is relevant to your job).