PolyMod: modular digital synthesizer

A customisable digital synthesizer. Works like an analogue modular synthesizer but cheaper, and with the ability to play many notes at once.

Similar projects worth following
PLEASE NOTE: I'm now working on an improved version of this project - follow for updates on the new version.

This project is a digital, polyphonic, modular synthesizer. Like a standard modular synth, my design consists of a number of removable modules, which are responsible for different elements of the sound (oscillator, filter, amplifier, etc), and which can be patched together to create unique sounds. However, while a standard modular synth is analogue throughout, my design is entirely digital. Instead of each module containing the analogue circuitry to generate or process an audio signal, the modules in my synth simply detect connections between each other and pass this data back to a Teensy 3.6 which is running a dynamically generated software synth.

All code for this project is open source!

Here's a video of me explaining how the synth is designed to be used:

And here's a piece of music I made to demonstrate the synth's capabilities:

How it works:

  • The synth consists of a Teensy 3.6 with a Teensy Audio Adapter, running a sketch which I have written myself. The sketch uses the extensive Teensy audio library to generate the audio, but in such a way that the functions of the audio library are abstracted into "modules" which have a physical counterpart
  • When the synth is powered on, the Teensy scans each of its seven module sockets. Each type of module has a unique ID number, which the Teensy can read from a hard-wired multiplexer on the module. The Teensy then knows which modules are in which slots
  • For each module detected, the Teensy's sketch creates a virtual equivalent of the module, effectively generating a custom software synthesizer
  • The Teensy sends a signal to each patch socket in turn (up to eight per module), and each time it sends a signal to a new socket, it also reads from each patch socket in turn, to see which sockets are connected to each other
  • When a new connection is detected, it is replicated in the Teensy's sketch. When a connection is broken, that connection is also removed in the sketch
  • If an output is connected to an output, or an input to an input, a red warning LED is flashed until the situation is rectified
  • If there is a complete signal path, with audio flowing from a module's output to the master module, audio is generated
  • The Teensy also continually cycled through each module's potentiometers, to check their current readings and pass this data on to each module's software counterpart
  • When a key on the musical keyboard is pressed or released, this data is received by the Teensy and converted to a virtual "control voltage" signal, which can be connected to any of the modules to generate melodies
  • The Teensy continually monitors the "mono/poly" toggle switch. When in "mono" (monophonic) mode, there is one virtual module for each physical module, and the synth can only play one note at a time. When in "poly" (polyphonic) mode, four virtual copies of each module are created, allowing for chords and harmonies to be played
  • The synth's code/firmware can be updated via the USB socket on the back. This makes it relatively easy to design and add new modules

JPEG Image - 3.20 MB - 10/22/2018 at 12:51


JPEG Image - 2.89 MB - 10/22/2018 at 12:51


JPEG Image - 2.86 MB - 10/22/2018 at 12:51


polymod BOM.xlsx

Bill of materials to build a PolyMod synthesizer

Microsoft Office - OOXML - Spreadsheet - 13.88 kB - 10/22/2018 at 10:01


  • 1 × See BOM in files section

  • Breadboard Polyphonic Synth Tutorial

    Matt Bradshaw03/13/2019 at 21:44 0 comments

    A couple of months ago, I pitched an idea to Hackspace Magazine: I would write a tutorial on how to create a miniature, breadboard-friendly version of the PolyMod synth. They said yes and allowed me to split the tutorial across two issues. Part one was published a couple of weeks ago, and part two should be out before long. Here's the link to the issue containing part one - there is a free downloadable PDF of the whole magazine, although I encourage you to buy a copy if you can!

    This was a fun and worthwhile diversion, partly because I wanted to provide an easier way to get started building a PolyMod-style synth, but also because taking the PolyMod concept back to basics was a useful intellectual exercise, forcing me to concentrate more on my code.

    I started by building an unwieldy three-breadboard design, before refining it down to two breadboards. This design included 16 patch sockets (oscillators, filter, LFO, amplifier, envelope, etc), an octave's worth of tactile buttons, two potentiometers, and a MIDI input. I was really pleased with how much I'd been able to squeeze in, but since the tutorial was in two parts, I also needed an even simpler (but still functional) design that builders could end up with at the end of part one.

    I wasn't sure whether it was possible, but with some cosy chip placement, I was able to get a design working on a single breadboard with 8 patch sockets (oscillators, LFO, filter, amplifier) and two potentiometers. The synth wasn't able to do much other than make annoying siren noises or filter sweeps, but it was technically a semi-modular synth on a single breadboard, which was cool.

    While the concept of the breadboard synth was based on the PolyMod, there were a few differences. Firstly, I didn't want to get into connecting and disconnecting virtual connections in the code, because it's a relatively undocumented feature and not hugely easy to explain. Instead, I did something a bit controversial and connected every single output to every single input simultaneously, via mixers, and just turned the mixer channels on and off to match the physical connections (see tutorial for more details).

    Connecting everything to everything else in this way doesn't scale very nicely, and therefore isn't really practical for the main PolyMod project, but it does have an advantage: since all the connections are going through mixers, it's possible to connect multiple outputs to a single input. Inspired by this, I'm going to try and write a more advanced virtual connection class for PolyMod 2, which will allow automatic mixing of input sources - this will have interesting uses for CV inputs, and obvious benefits for audio inputs.

    Keep an eye out for the next issue of Hackspace, which will hopefully feature part two of this tutorial, and let me know if you get stuck building the synth.

  • HackChat and new project

    Matt Bradshaw01/23/2019 at 14:04 0 comments

    Hello followers of the PolyMod project! Just wanted to let you know that I'll be doing a live HackChat (AMA) today (Jan 23rd) at noon PST / 3PM EST / 8PM GMT. Looking forward to answering some questions and maybe getting a few ideas from the community about what to do next with this project. Here's the link:

    Also, in case anyone is interested, I've started a new project for "PolyMod 2", the successor to this synth. It's still in the early stages but it's where I'll be posting updates from now on:

  • PolyMod 2.0: a rambling list of ideas

    Matt Bradshaw12/13/2018 at 14:20 0 comments

    It's a few weeks now since I finished the PolyMod prototype, and my head is now clear enough to think about what comes next. Here's a list of things that I'm imagining will feature in version two:

    • Easier to build
      • Use PCB's rather than stripboard
      • Design a 3D-printable case and 3D-printable module faceplates (while retaining the option of making it out of wood if that's your thing)
    • A bigger/better/extensible library of modules
      • A publicly editable database of modules, with version numbers, descriptions, graphical previews, etc
      • An online (open source) tool to generate custom Teensy code with your personal selection of modules included
      • Adding these features will move this project slightly closer to the appeal of modular synths, in that there could end up being a large and diverse variety of quirky modules to choose from
    • A display and menu system
      • This is controversial . There was something really appealing about the fact that the first version didn't have a menu system - having to navigate through a maze of sub-menus is one of the worst things about modern synths like the MicroKorg, but... there are some really cool features I could add if I had a simple menu system, such as:
      • Saving/retrieving patches, something that you can't do on a regular modular synth
      • Changing the "identity" of a given physical module without having to resolder anything - you could use the menu to let the system know that module #13, for example, is no longer a low-pass filter but is instead an eight-step sequencer
      • Maybe onboard audio recording? That would be pretty sweet, and within the Teensy's capabilities
      • I promise that you won't HAVE to use the menu system unless you're trying to alter a module's identity, which I think is a fair compromise. I realise I'm talking to myself now
    • External audio inputs would be pretty sweet
    • Better module design
      • Separating the design of the physical modules (many of which are similar or identical) from the design of the faceplates/front panels (which vary hugely), making it much easier to try out different modules by simply switching out the front panels (or even just relabelling them)
      • Allow double/triple width designs for more complex modules
      • LEDs!
      • A less fiddly way of mounting the modules (currently easy to be off by one pin, causing a short circuit)
      • DIP switches to give modules custom ID numbers
    • A MIDI input instead of a built in keyboard (probably)
      • The keyboard part of the previous project was a stupid idea - it was loads of work for something that works much worse than a normal keyboard
      • Doing away with a traditional keyboard will make the synth super compact
      • I might do a simplified keyboard instead
    • Future-proofing / modular design
      • If possible, I would like to design the new system so that it can be upgraded to Teensy 4.0 or a different processor in the future
      • It would be nice if the system's main "brain" was properly separated from the part where you plug modules in. Ideally, I would like an endlessly extensible system, where you could connect an unlimited number of modules, perhaps in blocks of 8 or 16. Maybe this is something for the more distant future
    • A more sensible form factor? Maybe something that could somehow integrate with Eurorack would be cool
    • Maybe use cheaper patch cables/sockets
      • It would be good to further bring down the cost of building the PolyMod
      • The 3.5mm cables and sockets I used on the previous version have two possible connections (nominally signal and ground), which makes them overkill for this project, where I only need one connection. I could happily get away with just using breadboard jumper wires and female headers
      • Using 3.5mm cables is also confusing because it falsely implies Eurorack compatibility

    Okay, that's enough typing. I suspect this new iteration will be different enough that I should make a new Hackaday project for it, so stay tuned!

  • The Next Stage: PCB

    Matt Bradshaw10/26/2018 at 13:45 0 comments

    It's been a couple of days since the Hackaday Prize finals submission deadline. I told myself I'd let this project sit for a while, since it now works well, but as I looked at the other projects with their neat schematics and PCB layouts, I realised I wanted to push my synth to that level. I'm now learning to use KiCad and it's really fun. I'm sure it'll take me a while to get my head around the process, but it would be really cool to be able to produce a version of my synth that doesn't take hundreds of hours to make, so here goes...

    I've got a bunch of other commitments but I'm aiming to get a PCB version of my synth working by the end of the year.

  • Finals Video

    Matt Bradshaw10/22/2018 at 12:15 0 comments

    One final update: since the requirements for the Hackaday Prize finals are a bit more stringent than the first round, I've made a new video which I hope explains the project a bit better:

  • Why I Made This

    Matt Bradshaw10/22/2018 at 07:25 0 comments

    This project is confusing to explain to people. Even quite technical people. Even quite technical musical people. It has layers of potential misunderstanding, like an onion which turns out to have a potato in the middle.

    First, you have to explain what a modular synthesizer is. A modular synthesizer is a collection of modules which each perform a single function, either to generate an electrical signal or to alter one. The user decides how the electrical signals are routed by "patching" different modules together with audio cables. Modules conform to a standard size and voltage range, and hence can be obtained from a huge variety of manufacturers before being installed alongside each other in a single case. Here is an image of a typical modular synthesizer (image credit Nina Richards

    Modular synthesizers have experienced a renaissance in the past few years, as people are attracted to the amount of control and invention available when compared to a regular synthesizer. The other main selling point is the analogue nature of the sound - there is a feeling that using analogue oscillators, filters, and other components gives an inherent warmth to the audio.

    However, it is wryly acknowledged among modular synth users that it is a very expensive way to make sounds, particularly when compared to software synthesizers. A full modular system with a keyboard is likely to cost £2000+, while extra modules can cost anything from £50 to £500+ each.

    These prices put modular synthesizers out of range of younger and poorer musicians, which is a shame. There are software equivalents, such as the excellent open source project VCV Rack, but they lack the tactile interactivity of a physical synth.

    This brings us to my project, the PolyMod. It is functionally almost identical to an analogue modular synthesizer. You still install individual modules in a case and patch them together to make a sound. However, rather than using an analogue signal chain, the PolyMod is basically a software synthesizer with a physical form. Here's how it works:

    The PolyMod consists of a Teensy 3.6 (basically a tiny computer) and a series of modules. Each module in the PolyMod is simply a collection of sockets and potentiometers, with no audio circuitry whatsoever. When the synth is turned on, the computer scans each module to see what type it is (oscillator, filter, amplifier, etc). If the computer detects an oscillator module, for instance, it creates a virtual oscillator module in a software synthesizer.

    The computer then continually listens for connections between the modules' sockets. If a patch cable is connected between the oscillator's square wave output and the synth's master stage, for instance, the software synth will also create this connection, and a square wave will be heard. If the user removes the patch cable, the software synth will delete the connection and the sound will cease.

    Performing the synthesis in this way means that I was able to build a working modular synthesizer (including eight modules) for about £150. What's even more exciting is that the modules themselves only require about £4 of components each.

    In a way, this is comparing apples with oranges. The appeal for a lot of serious modular synth users is, after all, the pure analogue sound, whereas the PolyMod produces all its audio digitally. However, I think the audio quality is certainly good enough to be of interest to people who couldn't afford an analogue modular setup. What's more, there is one rather exciting feature that the PolyMod has, which can't be replicated on an analogue modular synth... polyphony!

    Analogue modular systems are geared towards playing one note at a time. Playing chords or harmonies (more than one note at once) is technically possible, but requires a lot of modules and an awful lot of patch cables - this discussion...

    Read more »

  • Lots of photos!

    Matt Bradshaw10/21/2018 at 13:01 0 comments

    Well, rather excitingly, I was one of the winners of the musical instrument category! This means I'm now doing a last-minute scramble to make sure my project is fully documented ready for the finals deadline. Accordingly, here are lots of photos of my synthesizer, inside and out.

    This is the synth with all its modules in place, ready to play, viewed from a few different angles:

    There are two sockets on the back: a standard 1/4" audio output jack, and a USB power input, which can also be used to upload new code to the Teensy.

    This is what the synth looks like it with no modules in it. Note the metal threaded inserts at the top and bottom, which allow the modules to be securely screwed in place, and the slotted wooden section just below the white circuit board, which helps to align the modules.

    Here is a close-up of the 12-pin module headers. This circuit board is mounted on nylon standoffs.

    Here is a typical module (this one is a filter) with three knobs and six sockets.

    Viewed from another angle, you can see how the second row of sockets is mounted using nylon standoffs.

    I took a photo of two modules side by side to demonstrate that there is almost no difference in circuitry between different modules. The only thing that really changes is the layout of the knobs and sockets.

    Back inside the synth now, this photo shows the back of the master module, which has a monophonic/polyphonic toggle switch, a volume control and a couple of LEDs. The unusual L-shaped board was a compromise to allow the Teensy to sit below the master module - I will change this in the future.

    And here's a photo of the main circuit board, which is basically just a Teensy (with an audio board) and four 4051 multiplexer/demultiplexer ICs. The overwhelming number of wires (which mainly communicate with the modules) is a weakness of the design. I hope to solve this in my next prototype, which is very likely to use a proper PCB rather than stripboard!

    Finally, here's a look at how the keyboard mechanism works. Again, it's a bunch of multiplexer chips (I promise I do sometimes use other chips, this project just happened to need loads of the same one!). There is a tactile button under each key, and the keys themselves were borrowed from an old toy keyboard and secured with machine screws.

  • Basic Demonstration Video

    Matt Bradshaw10/08/2018 at 13:50 0 comments

    I've made another, less musically interesting video where I demonstrate the basic functionality of the synthesizer. EDIT: I've since made a better demonstration video here for the finals:

    I'm really happy with how this whole project turned out. I wasn't sure whether the Teensy would be powerful enough for polyphonic synthesis of this complexity, but it worked brilliantly. I also worried that latency would be an issue, but I've managed to iron out any problems and latency is currently imperceptible.

    I have a few ideas for future improvements, such as adding a save feature for patches, and adding onboard audio recording, but mainly I just want to keep designing and adding modules and experimenting with the synth to see what kind of sounds I can get out of it!

  • It's Finished! Demo Video

    Matt Bradshaw10/07/2018 at 22:29 0 comments

    It's done! Very long weekend but the synth is finished (for now) and I've made a demo track, which you can watch below:

  • The Final Stretch

    Matt Bradshaw10/06/2018 at 08:24 0 comments

    It's Saturday, 9 AM, two days until the deadline. Oxford is grey and murky. I'm psyching myself up for the final push, watching the Battlebots final while I wait for the clock to tick round to a reasonable hour to use power tools on a weekend.

    Over the past couple of weeks, I've battled against my limited woodworking skills to build a plywood case for my synth, upcycled from an old bookcase I found abandoned on my street. Here's what it looks like at the moment:

    The modules are now supported by an angled shelf, and (once I have built front panels for them) will be held in place by thumb screws, screwed into threaded inserts both above and below.

    The keyboard is now also in place. There was no real need for a keyboard for this project, and most people would have simply added a MIDI input instead, but I wanted a standalone instrument that I could play with minimal setup, so I looked for ways to include a keyboard. I settled on repurposing the plastic keys from a cheap toy keyboard, positioning each key over a tactile button and routing the 32 keys through four multiplexers to reduce the number of Teensy pins required. I could have gone further and reduced the keys to just one pin, but I was doing okay for pin availability and was also worried about latency, so settled for four.

    I've also added USB and audio jacks on the back of the synth. Top tip: whenever possible, avoid square holes. Maybe there's a good way to cut square holes in a way that isn't messy and/or slow, but I certainly haven't found it yet.

    Anyway, here's my ambitious plan for the final weekend of the project:

    • Drill holes in the module front panels to accommodate the sockets and potentiometers
    • Assemble the modules and test each one
    • Add a toggle switch to choose between monophonic and polyphonic modes, and adjust the code accordingly
    • Cut remaining wooden parts: main front panel, keyboard circuit cover panel, angled panel beneath the modules
    • Attach the remaining wooden parts
    • Spend some time playing the synth, adjust the code if required
    • Plan composition video (some ideas already, excited about this!)
    • Record composition video, edit and upload
    • Update/create Fritzing diagrams
    • Draw exploded diagram (or similar) of project
    • Do super-detailed write-up of project on Hackaday
    • If I have time, disassemble and reassemble project on camera for time lapse video
    • Sleep

View all 15 project logs

  • 1

    This project involves code, electronics, and (if you want to build a case) woodwork. As well as the items listed in the bill of materials (in the "files" section of this project), here are the tools you'll need before you get started:

    Software: Arduino IDE and Teensyduino for uploading code to the Teensy

    For the electronics: soldering equipment, stripboard track cutter, wire cutters, wire strippers, crimping tool (optional - you could buy pre-crimped cables)

    For building the wooden case: hand saw and/or circular saw, drill, screwdriver, hex keys

    N.B. The instructions listed here should be sufficient for you to recreate my prototype synth. However, there are likely to be features that you feel are unnecessary or that you would like to implement differently, so I would recommend only using these instructions as a guide for you to create a synth that is suited to your own needs. Don't be afraid to diverge from my design decisions!

  • 2
    Assemble the main circuit board

    Position the components and wires according to the illustration below. Solder the components then cut the tracks. Make sure to use headers rather than soldering the Teensy directly to the stripboard, and don't add the Teensy just yet.

    You'll notice that most of the module headers are not connected in the diagram - there are so many wires that it would be confusing to show on the illustration, and I'm not very good at schematics! Basically there are four wires for each module socket that need to be wired to the appropriate channel on each of the 4051 chips. You can see in the illustration that socket 7 has been fully wired up already. To wire up socket 6:

    • Pin 3: wire this to channel 6 of the first 4051 chip
    • Pin 4: wire this to channel 6 of the fourth 4051 chip
    • Pin 5: wire this to channel 6 of the third 4051 chip
    • Pin 12: wire this to channel 6 of the second 4051 chip

    You'll need to refer to a diagram of the 4051 chip to see which channel is on which pin. Once you've wired up channel 6, wire up the other sockets in the same way (i.e. the wires from socket 5 go to channel 5 of the various 4051 chips).

    Here's a photo of how the module sockets are supposed to look, in case that helps!

  • 3
    Add the Teensy

    Solder stackable (extra long) headers to the Teensy, such that it is has male pins protruding below and female headers on top. Solder male headers to the Teensy audio board, such that its pins protrude below, and push the audio board's pins into the Teensy's female headers, making sure the pin numbers are aligned.

    Test the Teensy before connecting it to the main circuit board by uploading some test sketches from the Arduino IDE. Try "Basics/Blink" to test the Teensy itself and "Audio/Synthesis/PlaySynthMusic" to test the audio board (music should play through the headphone socket).

    Next, carefully push the Teensy into the appropriate female headers on the main circuit board and check it still works. If it cuts out or you can't upload sketches any more, disconnect the cable and check your soldering.

    If everything is good, you can upload the PolyMod sketch, which can be found on the PolyMod GitHub repo:

View all 13 instructions

Enjoy this project?



Bdembowski wrote 03/31/2019 at 21:03 point

Hi there.

I'm going to have a go at building the Hackspace version of the PolyMod synth. Although I'm an experienced musician and electronics enthusiast, I've only recently started learning Arduino programming and have had no experience with the Teensy. So this will be my first big project and hopefully you or the other contributors can give me some advice If I get stuck.

If I get the breadboard version  up and running, I would like to make a more robust permanent working synth and I was thinking about using banana plugs and sockets for the Patch Matrix which leads me to question 1 :  Is it ok to patch two, three or more CV signals into the same input or will that cause conflict? eg patching envelope CV, Key CV and LFO  into  the SAW OSC input.

Question 2: Can this synth be integrated into other CV/Gate synth modules?

Bernie Dembowski

  Are you sure? yes | no

Alexander wrote 01/29/2019 at 16:44 point

I have followed this project for a while, and I absolutely love it. It looks great, sounds great, and piques my love for synths. I play around with my Midibox every now and then but your project just sounds so... awesome! The idea of making a digital synth which connects like an analogue one is incredible. I want to play with it!

  Are you sure? yes | no

Matt Bradshaw wrote 01/29/2019 at 17:09 point

Thank you! Really happy you think it sounds good. I was in a synth store yesterday playing with some really nice Eurorack modules, and it inspired me to keep pushing on with this project. Keep an eye on my other project (PolyMod 2), where I'll hopefully be posting some exciting updates over the next few months :)

  Are you sure? yes | no

Alexander wrote 01/29/2019 at 17:31 point

That sounds amazing! I seriously need to sit down and build a synth, even if it's just a kit based on someone else's design (like yours). It's so satisfying after all that soldering to hear sounds coming out of your creation!

  Are you sure? yes | no

Tillo wrote 01/25/2019 at 14:54 point

Just looked at it right now. Just as a pretty cheap and easy idea for face plates. Do it as PCBs, if ordering the PCBs the can easily added to the panelization, its pretty sturdy (1.6mm FR4) and can look amazing ;)

  Are you sure? yes | no

Matt Bradshaw wrote 01/25/2019 at 16:34 point

Thanks Tillo, that's a really good tip, am quite likely to do that :)

  Are you sure? yes | no

eddydepoorter.23 wrote 01/21/2019 at 19:26 point

Amazing work !!! I've worked on something similar last summer but with switched jack sockets and sending messages to pure data for live patching of modules. Your solution is way clever !!!

  Are you sure? yes | no

Matt Bradshaw wrote 01/25/2019 at 16:30 point

That sounds like a really cool alternative, did it work well? Would be interested to see the results!

  Are you sure? yes | no

Stefano Garuti wrote 01/15/2019 at 12:39 point

Really really really great job! Wonderful documentation too! 

I Like a lot your plan for the 2.0 version too. 

Until today I focused on build MIDI controllers.. your project could be the spark that get my starts with audio generation too. Btw, Teensy is great! ;-)


  Are you sure? yes | no

Matt Bradshaw wrote 01/15/2019 at 17:58 point

Thank you! Yes, designing MIDI controllers is how I got started, too :)

  Are you sure? yes | no

rafununu wrote 12/10/2018 at 15:02 point

Hi there, I'm not very familiar with Arduino (even if I developped a lot i the past... but in assembler) and looking at your code on github, in the .ino file, the ENVELOPE_MODULE is written twice (line 118), it must be the CRUSHER_MODULE I think. Congrats, your code is pleasantly readable and well structured. I like the idea of creating virtual analog modules in a digital environment. I'm gonna make something very similar but with a matrix, as on the EMS AKS.

  Are you sure? yes | no

Matt Bradshaw wrote 12/10/2018 at 15:10 point

Hi, thanks for the nice comment :) Yes, that line does look a bit odd, but I can explain. That whole block of code (from line 108 to 119) is actually currently unused (note the if(false) statement). It was a section of code which allowed me to simulate modules in software before I had actually built them, and the two envelope modules were because I wanted to use one as an amplitude envelope and the other as a filter envelope. Hope that makes sense!

  Are you sure? yes | no

Roger Labbett wrote 11/29/2018 at 14:49 point

This is a really inspiring project. I have been tinkering with the Teensy Audio Library for about a year with a view to building a synth.  Recently I have been juggling with the apparently conflicting requirements of creating a presentable and usable instrument that isn't just a breadboad rats nest while allowing for future expansion and experimentation.  I think you have solved my problem. Good luck with the competition!

  Are you sure? yes | no

Matt Bradshaw wrote 12/10/2018 at 15:11 point

Thanks Roger! Really happy my project helped you :) Would love to see what you make.

  Are you sure? yes | no

Roger Labbett wrote 12/16/2018 at 16:44 point

I have got the extra hardware I need on order and am hoping to make a start over the Christmas break if everything turns up in time.  I am a metalworker rather than a woodworker, so mine will be built in aluminium.

  Are you sure? yes | no

purbannavage wrote 10/18/2018 at 17:22 point

Wood...right up my ally. Nice job!

  Are you sure? yes | no

Matt Bradshaw wrote 10/21/2018 at 11:25 point

Thanks! Someone was throwing away a plywood bookcase on my street and I thought it'd make a nice synth :)

  Are you sure? yes | no

Similar Projects

Does this project spark your interest?

Become a member to follow this project and never miss any updates