The Vult prehistory
Updated: Oct 18
Some days ago I had an interesting conversation with a fellow synthesiser enthusiast. During the conversation he asked me about Vult's timeline. I really don't remember exactly when I started doing what. But since I have documented many events using pictures and I also have the dates in the repositories and publications, I think I can reconstruct the timeline.
My story starts way back, when I started doing electronics with my dad at a very young age. But let's start in 2005, the year where I packed my stuff and took a flight to a new continent to start a completely new chapter in my life.
September 2005 to 2011
I did a PhD in Industrial Electronics in Madrid Spain. The lab that I was working on had a research area on modelling a simulation. During this period I learned a lot about these topics while working on projects for different companies. During these years I developed a tool to symbolically analyse dynamic systems. I used this tool to analyse magnetic components, power converter and guitar pedals. My tool was able of extracting simplified differential equations out of schematics. This was the foundation of all the Virtual Analog that I have been doing.
I started working at Wolfram Research developing the simulator and compiler behind SystemModeler. I still work here in present day. This job really sharpened my skills in compiler design, mathematical modelling and simulation techniques.
To test the simulator I would always create models of electronics applied to music, like guitar pedals. My intention was to better understand how these systems are designed.
One of the first resources I got was the book of the Elektor Formant synthesiser. I was lucky to find it second hand. I started modelling and simulating all the circuits in the book.
The first time I used the Vult name was when I started developing the Vult language. This was in fact my second try of making a domain specific language applied to DSP. A few months earlier I started experimenting with writing DSP code in imaginary programming languages using different paradigms: functional, class based, agent based, etc. After writing different algorithms in all the languages I decided that the simplest and more clear way was the current style. At this point I started writing the code and made the first commit to GitHub.
The code of Vult is written in OCaml, a great programming language.
At the beginning of the year I had a conversation with an artist called John Klimt. After telling him my vision for the Vult logo, he helped me design it and I have been using it since then.
At this point I had a working version of the compiler. Back then I was using a lot the Teensy 3.2 boards for small audio projects. Since these microcontrollers did not have floating-point unit, I added support for fixed-point code generation to my compiler. This allowed me to code a small (but complete and great sounding) synthesiser running in the Teensy board.
Around this date I decided to start building an Eurorack synthesiser. I went to IKEA and got a piece of furniture. With a few modifications I turned it into a suitable two row 84 HP rack. I designed 3D printed ears and got a pair of rails.
All the Eurorack modules I had were based on DIY kits. Since I'm quite experienced at designing electronics, I decided to start experimenting creating my own modules based on Arduino and Teensy boards. The code was written in Vult language.
I got a kit with a panel and breadboard for Eurorack and I built a generic module. It consisted of one analog output and a few knobs. I wanted to create a simple kick drum. I tried to find some of the old simulation models I created and I started to simplify it in order to make it run on the board.
Here's a demo of the kick drum. This model some time later would become the famous Vult Trummor 2.
At this point I had support for Pure Data and Max externals. I started creating more complex synths using the blocks I created with the Vult language.
A friend of mine invited me to give a talk in the Openfest, an open source conference in Bulgaria. I gave the following talk there where I showcased the Vult language and the Pure Data externals (check the last minutes of the video).
I decided to make a module from scratch. I wanted to design the panel, the PCB and make it look professional. I picked the Steiner-Parker filter (Yusynth version) because it seemed to me like an interesting circuit to try. Making the electronics was straightforward, but designing the panel the way I wanted wasn't. I made a few mistakes that helped me understand better how modules should be designed. For example, that one has to consider the space for the fingers.
I didn't sell this module. I gave away the PCB and panels for free to my friends.
I started developing the concept of a virtual modular synthesiser based on the Vult language. The idea was to create and AudioEngine in charge of making the audio processing using JIT compilation and attach a web-based application that replicated Eurorack panels.
This idea was a bit ambitious. Specially on the web development because at this point I was not very familiar with the technologies. I stopped developing this idea when I found about VCV Rack.
I still have plans to finish the JIT engine but just for prototyping purposes.
VCV Rack was publicly released. After looking at the code I decided to port some of the Vult code I had and make two modules: Rescomb and Stabile. I released these modules a few days after the launch of VCV Rack.
Filters are the synthesiser blocks that interest me the most. I started modelling more filters. First, I made a model of a ladder filter that I built in a breadboard. The second was a model of the Steiner-Parker circuit I made a few months back.
Since then I have modelled many more analog filters.
Up to this point, all the models I was developing had one objective in mind: performance. All my models were simplified up to the point where I could run them in small microcontrollers. That required me to sacrifice detail in the models making them less realistic. At the same time, I stared receiving emails from people wanting to use my source code (which was open-source) but they were not very happy to comply with my terms. I got a bit disappointed because all my efforts in developing good models were very easy to exploit by third parties without even making a reference to my work. Some open source projects do not have this problem. For example VCV Rack. Nobody can claim that they wrote VCV Rack but Andrew. But in the case of my filters code, it is very easy to copy and nobody would know who wrote the original code. For that reason (and many others) I decided to close my source.
Closing my sources allowed me to spend time making complex models and create core IP of Vult. Closed source also help me to create my first product in the VCV store: the Vult Premium package which initially contained my model of the Polyvoks filter. The small revenue I had from selling licences helped my justify the vast amount of time I was spending developing models.
During the following months I reworked all my modules using more advanced models.
After modelling more than 8 filters, I decided to package all of them in a more convenient module that I called the Freak Manifold Filter. It was during this time where I got the idea of making it a real module. I spend a few months optimising the code to make it possible to run in a ARM microcontroller and after developing a proof of concept I started designing the electronics behind the module.
I received the first PCB of the board used in the Freak filter. I called this board "Aire" (Air in Spanish) and it's the central part of the module. Fortunately, the board worked just fine. With this board working I could start putting effort into the other parts of the project.
I started working on a new model based on the OTA version of the MS-20 filter. When I finished the model, rather than disassemble the breadboard circuit, I decided to make a PCB for it. I really liked this filter. While I was designing the software version (Vorg) I decided to consider the real size of the components and make it look (even more) like a real module. Having the PCB designed and a realistic panel, the only thing left was to turn it into a real module. When I shared my idea with some of my synth-friends they told me that they were interested on having one.
After working a few months on improving my Vult compiler, I got it to the point where I was able of generating Java code. This allowed me to port some of the Vult modules to Cherry Audio Voltage modular.
After a few revisions of the Vorg PCB, I got it working. I manually assembled a small batch of filters. The filter was very well received. This made me consider the possibility of turning Vult into a real boutique of modular gear.
Even when I think that the Freak module is great, I was not really sure how well it was gonna be received. Rather than ordering 100,000 boards from the fab house I decided to make a small batch, just in case I sold only 10 and I had to throw in a landfill the remaining 99,990 modules. My plan was to make a "quiet" release, posting it only on the Vult facebook so it could reach only the people that know about the project. That way it would give me time to react and re-stock all the parts in time if the sells went fast.
We have to make the final assembly and testing of the module manually. This takes quite some time.
August 2019 (Today)
We are still figuring out if manufacturing Eurorack modules is a viable business. The modules I make are not necessarily cheap because they are not manufactured in very large quantities. There are many players in the Eurorack world and most of them do it for passion, just like me. There are lots of interesting modules. Making hardware modules is a lot of fun but it's not an easy task.
More people are trying to make the jump from designing software Eurorack to hardware, but I have to say that is not easy. Even for me that I'm a somewhat experienced designer the things haven't been very smooth. It's not the same making one module for myself compared to making a module to sell to hundreds of people.
I have already started designing more hardware modules, mainly because I want to have them. If I'm satisfied with them I will make them available to more people.