My visit to the MIDI HACK

Electronics, Music, Synthesizers

Last May 17-18 I attended to the MIDI HACK, which is by far the coolest Hackathon out there (IMO). Is not that I have been in others, but this one matched perfectly the kind of hacks that I like to make.

I had a great time surrounded by people with the same obsessions as me: music, electronics and computers. The event was great, it had nice food, a lot of drinks, coffee and the most important thing: the aura.

At the beginning I had no idea what I was going to build. So I spend the first three hours moving ideas in my brain and trying to come up with something feasible and not repeated. After looking at my bag I decided to do something that I wanted to do two years back…

I had in my bag a Monotron, a Meeblip and some Arduinos. So I decided to put them together and add some extra sauce by connecting a Raspberry Pi to handle OSC messages.

After some hours I decided to drop the Raspberry Pi because I couldn’t connect it to the Spotify’s  WIFI but it works fine otherwise.


This is a picture of the project:



And this is a more detailed diagram of the connections.


So, The RPi runs Node.js and connects to the Arduinos by using the Arduino Firmata. One of the Arduinos sends CV signals to the Monotron in order to control the gate, pitch and cutoff. The second Arduino connects to a custom-made board containing knobs, buttons and LEDs.

The Meeblip is connected by using a standard USB to MIDI converter. The audio of the Meeblip is fed into the Monotron and it uses a potentiometer to control the amount of audio.

The custom controller is used to adjust a few of the parameters of the Meeblip.

Here you can find the code that runs in the RPi.

And here is the entry to the hackathon

MicroBruto: a Max For Live simplesizer

Create, Music, Synthesizers

I have been watching demos and reviews of the Arturia MicroBrute and it seems like a very interesting synthesizer. It’s analog, cheap and flexible. But before even thinking about getting one, I wanted to “experience” the user interface. That’s why I decided to make the MicroBruto. ‘Bruto’ in Spanish can be translated as gross or stupid, but I have to clarify that the name does not reflects my option about the synthesizer. I just thought it was funny.


Arturia MicroBrute

Arturia MicroBrute

The MicroBruto

The MicroBruto is not an emulation, is just a digital synthesizer with controllers inspired by the MicroBrute. I tried to imitate the functions of the oscillator, the envelope, filter, LFO and most important: the modulation matrix.

Here you can see a screenshot:



The beauty of this synthesizer is that is does not need a manual. That’s why it is a Simplesizer.

You can get the device from the page. HERE

The marketing of shiny things

Absurd, Art, Synthesizers

This week I saw on the following video (that amazingly it has more than 3 million views):

If you don’t want to check it all I’ll give you a small summary. The video presents a new software for making music, in which the marketing was made by professionals that do not have a clue about the music software market. I said professionals because it seems that they are doing a correct campaign. However I think is not really effective.

In that video these guys present a simple and affordable solution that will help you make good music. They claim that is so easy that you don’t need to study music theory, learn complicated stuff o buy expensive gear… and the weirdest thing is that they say that your friends will envy you…

Guys of Dr. Drum, I have to tell you that when I buy software or hardware I search exactly for the opposite.

I don’t like shiny things,  I like it dirty.

We love complex stuff, we love learning.

That’s one of my principles. That’s what I pray every morning.

Music software and hardware is complex by nature. It’s mysterious and intriguing, but is friendly. Even the simplest machine plays an important role. For example this AB Switch pedal.

It’s function is to route the guitar signal to two different destinations. It’s easy to use and it allows doing amazing stuff.

When I see one of these images I start drooling…

These images are pure beauty.. these are machines of controlled chaos…

I think that all the music is chaotic, and harmony it’s just a piece of it that our senses got used to.

The perfect balance

Ernst Nathorst-Böös nailed it with Reason. In this talk he mentions the key point of a music software.  The software needs to be simple but still having a level of complexity.

We need to feel that every song, every sound we make is our own sound.

Even if my songs are crap they are still my crap and I’m happy. That’s why I can spend long hours preparing a sound.

In the chaos I can let myself go…

BTW. The Reason screenshot is one of my songs.

Developing Pure data externals in Visual Studio

Create, Music, Synthesizers

Some weeks ago I started learning Pure Data. I have known it for a long  time but I never used it since I made my music in other tools.

During the years I have seen amazing stuff  made using PD.  You can create 3D graphics, connect it with Arduino,  using OSC protocol and many more thing.

Connecting blocks with PD is very easy and the combination of text and wires makes it very effective. For example if you want to make a simple block that adds a constant to a signal you just need to type “+ 2″… amazing isn’t it?

In my case, PD is great to prototype and test algorithms, and the fact that you can create your own blocks using C language is great.

I was checking the developer documentation and the tutorials to create extensions. This one was very useful to understand how  the things work.

HOWTO write an External for puredata

However this document is platform independent  and I wasn’t sure what I needed to create and extension using Visual Studio. For that reason I made this small tutorial.

Compiling the hello world example.

The “HOWTO write an External for puredata”  contains the following code:


#include "m_pd.h"

static t_class *helloworld_class;

typedef struct _helloworld {
 t_object x_obj;
} t_helloworld;

void helloworld_bang(t_helloworld *x)
 post("Hello world !!");

void *helloworld_new(void)
 t_helloworld *x = (t_helloworld *)pd_new(helloworld_class);

return (void *)x;

void helloworld_setup(void) {
 helloworld_class = class_new(gensym("helloworld"),
 0, sizeof(t_helloworld),
 class_addbang(helloworld_class, helloworld_bang);

Just put the code in a file named “helloword.c”.

In order to simplify the project creation I used CMake. Download the latest version and install it. Note: I have added the path to the binaries to the PATH variable.

You need to create the following two files.


LIBRARY helloworld
EXPORTS helloworld_setup

This file is to let know the compiler that we are exporting the symbol “helloworld_setup”. The following file is the cmake project file. This one is going to make most of the magic.




set(SRC helloworld.c)

include_directories("C:/Program Files (x86)/pd/include")
link_directories("C:/Program Files (x86)/pd/bin")

add_library(helloworld SHARED ${SRC} helloworld.def)

target_link_libraries (helloworld pd)

Generating the project files

CMake files are very simple to understand, you define the sources (line 5), you add the includes and libraries directories (lines 7 and 8). The includes and the libraries are located in the folder of your PD-extended installation.  In line 10 we define that we are creating a shared library using the sources in variable SRC  and we also supply the helloworld.def file.

The new step is to open the command line. Note: you need to able of calling the compiler (cl.exe) from the command line. For that reason I use the shortcut included in the Visual Studio tools menu.

Once in the command line, go to the path where you have the files located and run the following command to generate the project files for Visual Studio 2010:  cmake ./ -G “Visual Studio 10”.  This will generate all the project files you need.

If you have problems following these steps, you can also refer to the cmake tutorial in HERE

Compiling and debugging your extension

Compiling is straight forward. Open the “ALLBUILD” project in visual studio and build the solution.

In order to debug you new extension you need to make it like any other DLL. You need to make PD use the DLL and attach the debugger. To use the DLL in PD you need to add the path to your debug DLL. You can find where the DLL is by looking at the project properties.

To add the path into PD go to File->Path menu and add a new entry.

After that you need to tell PD to load the DLL when it starts. In the menu File->Startup add the “helloworld” entry.

The next step is to configure the debugger. Since we are compiling a DLL we need to to configure the debugger to run PD instead. In the Properties of the helloworld project, in the debugging tab set the “Command” to the path of pd.exe and preferably the working directory to the same path.

Now just add a breakpoint, run the debugger and see it stop when you’re using your extension.

Hope this small tutorial simplify some steps for you. I’m planning to make a few more explaining other aspects.

Aphex Twin changed my life too


I was watching this video where this guy comments the strong influence that Aphex Twin had in his musical career… and some way I feel the same.

The first time I listened to Aphex Twin was on MTV (when it used to be good). I saw the video “Come to daddy”

That SCREAM !!!!

For the first time I realized that not all electronic music was meant to enjoy only with drugs.

The same way that not all songs that use a guitar fall in one classification, not all the songs that use synthesizers are the same… some music just sucks.