April 20, 2015 »

Raspberry Pi Revisited

When the Raspberry Pi 2 was released I certainly got curious. Would it be really better than it's little brother? As soon as it got available in The Netherlands I bought it and sure this thing flies compared to the Raspberry Pi 1. The four cores and 1GB of memory are certainly an improvement. The biggest improvement though is the shift from ARMv6 to ARMv7. Now you can really run basically anything on it and thus I soon parted from Raspbian and I'm now running plain Debian Jessie armhf on the RPi.

So is everything fine and dandy with the RPi2? Well, no. It still uses the poor USB implementation and audio output. And it was quite a challenge to prepare it for its intended use: a musical instrument. To my great surprise a new version of the Wolfson Audio Card was available too for the new Raspberry Pi board layout so as soon as people reported they got it to work with the RPi2 I ordered one too.

Cirrus Logic Audio Card for Raspberry Pi

One of the first steps to make the device suitable for use as a musical device was to build a real-time kernel for it. Building the kernel itself was quite easy as the RT patchset of the kernel being used at the moment by the Raspberry Foundation (3.18) applied cleanly and it also booted without issues. But after a few minutes the RPi2 would lock up without logging anything. Fortunately there were people on the same boat as me and with the help of the info and patches provided by the Emlid community I managed to get my RPi2 stable with a RT kernel.

Next step was to get the right software running so I dusted off my RPi repositories and added a Jessie armhf repo. With the help of fundamental the latest version of ZynAddSubFX now runs like charm with very acceptable latencies, when using not all too elaborate instrument patches Zyn is happy with an internal latency of 64/48000=1.3ms. I haven't measured the total round-trip latency but it probably stays well below 10ms. LinuxSampler with the Salamander Grand Piano sample pack also performs a lot better than on the RPi1 and when using ALSA directly I barely get any underruns with a slightly higher buffer setting.

I'd love to get Guitarix running on the RPi2 with the Cirrus Logic Audio Card so that will be the next challenge.

by Jeremy at April 20, 2015 07:32 PM

Scores of Beauty

“Defining a Music Function”

It’s been about a year since I started a category with Scheme tutorials, and back then I declared them as a “documentation of my own thorny learning path”. By now I’ve experienced a significant boost in Scheme “fluency” which was triggered by (and at the same time enabled) a number of projects and enhancements, for example the ScholarLY package and the jump into a fundamental redesign of openLilyLib. I thought it would be a good idea to pick up the tradition of these tutorials before I forget too much about the difficulties of finding my way around LilyPond’s Scheme. This is of course not a carefully crafted “curriculum” but it will always be a random collection of (hopefully) useful snippets of information, each one written with the goal of explaining a single topic in more depth and at the same time more casually than the LilyPond reference can do.

Today I’m writing a tutorial that I would have needed a year ago ;-) about one thing that always vaguely confused me. I usually managed to just get around it by either routinely “doing it as always” or by getting some ready-to-use code snippets from a friendly soul on lilypond-user. This is the topic of defining music-/scheme- and void-functions in Scheme. I will analyze a music function I introduced in last years’ posts and explain what is going on there. Understanding this gave me surprising insights, and I think knowing this kind of stuff is really helpful when trying to get more familiar with using Scheme in LilyPond.

So this is the simple music function we’re going to dissect, it takes a color? argument and applies that color to the next note’s note head and stem:

colorNote =
#(define-music-function (parser location my-color)
     \once \override NoteHead.color = #my-color
     \once \override Stem.color = #my-color

  c' \colorNote #red d' c'

(See the other post for the output of that example.)

This is something I knew how to put together for quite some time, but I’ve always wondered about a few things here (just managed to suppress the questions, because it did work), particularly the relation between the colorNote = and the #(define-music-function part and the parser location arguments. But to be honest, I wasn’t really clear about the part returning the “music expression” either.

In the current post I will go into quite some detail about the declaration/definition of the music function and the topic of “return values”. However, I’ll skip the third issue because that’s somewhat unrelated to the other two and because the post is already quite long without it.

Defining the Music Function

Let’s start with looking at it from the perspective of the “user” or “caller”. colorNote is a “music function” that returns a “music expression”. This is the part enclosed in the #{ #} brackets, containing two overrides (yes, overrides are also “music”) and applying the #my-color argument passed into the function. So when writing \colorNote #red it’s quite obvious that I call the function colorNote, passing it the argument #red.

But the syntax of how this “function” is defined somehow always startled me, and I’m sure there are many others who could write such a function too, without really knowing what they are doing. Let’s have a look at a comparable function definition in Python (for those who know Python):

def colorNote(parser location color):
    return some_music_expression

Here the syntax is clear that we are defining colorNote to be a function object, taking some arguments and returning a value. When we use that function later in the code the program execution will jump right into the body of that function definition. But what do we actually do when “defining a music function” in LilyPond?

From the LilyPond documentation (and last year’s posts) we learn that the following expressions are equivalent:

myVariable = 5

#(define myVariable 5)

Both define a variable myVariable and set its value to the integer number 5. Or, expressed the other way round, they take the value of 5 and bind it to the name myVariable. Later in the program (or the LilyPond file) one can refer to this name and get the value back.

We can rewrite the definition using the #(define syntax like this:

#(define colorNote
   (define-music-function (parser location my-color)
     ; ...

So what is the value we are binding to the name colorNote in our example?

Intuitively I would expect that we bind a function’s implementation to the name colorNote, similar to what the Python example seems to do. But here we don’t seem to assign a function or function body but define-music-function instead. If you start thinking about it this seems very strange. Fortunately you can continue thinking about it and it becomes clear, so stay tuned…

Maybe you notice a small but important difference to the above definition of myVariable: define-music-function is enclosed in parentheses, while 5 was not. Parens (usually) indicate we are calling a procedure in Scheme, and this call evaluates to something. Whenever you want to use a value you can instead call a procedure, and the value this procedure evaluates to is then used as your value. (You may want to read this paragraph again… or consider the following mathematical examples. In Scheme (+ 3 2) evaluates to 5, (- 3 2) evaluates to 1, and (+ 3 (+ 1 1)) evaluates to (+ 3 2) which then evaluates to 5.)

So what we really do with our music function is call define-music-function which evaluates to a “music function” and bind this result to the name colorNote. Later in the LilyPond file when we call \colorNote we do not execute the code after \colorNote = (which is what would happen in the Python example) but instead we call the music function that has been created when \colorNote has been initially parsed. (For a more detailed and technical discussion you may read the Wikipedia article about “first class functions”).

define-music-function <argument-list> <argument-predicates> <body> itself takes three arguments, each enclosed in its own parenthesis (here the parens are used for grouping items to a list and not for a procedure call):

  • the list of argument names:
    (parser location my-color)
  • a list of argument predicates (types that the arguments have to have)
  • the actual implementation body

my-color is an arbitrary name that has been chosen for an argument. It lets you access the value that has been passed into the music function at that position. Note that this is the only argument that the user has to supply when calling the music function, parser and location are passed implicitly. According to the manual parser location simply has to be copied literally, which is also confusing – but we won’t go into this detail today.

color? is the type of the (single) value that can be passed to the function, so you can’t for example write \colorNote #'thisIsNotAColor (which would pass a Scheme symbol to the function).

Side note: You also can define music functions that don’t have such arguments, so the first element in define-music-function would be (parser location). It has always startled me why I’d have to add () in such cases, but now this becomes clear: define-music-function expects a list of argument predicates as its second argument, and if there are no arguments to be type-checked then this second argument is still expected, and an empty list has to be passed as the <argument-predicates>.

The “Return Value” – Music-, Scheme- and Void Functions

Digression: “Procedures” and “Functions”

Before going into the topic of the different function types I have to dwell on a certain fuzziness in terminology: procedures and functions. When reviewing this post I realized that I wasn’t completely clear about the distinction and used them interchangeably. My request on the lilypond-user mailing list raised a discussion showing that it actually isn’t a trivial topic. So while in the end it is more or less neglectable there are things you may want to digest in order not to get confused when people use these terms in the LilyPond/Scheme context.

Some programming languages make a distinction between procedures and functions, some don’t. If a language distinguishes, it is mostly the question of a return value: functions return a value, procedures don’t. This means that while both are separate blocks of code that can be called from within a program, functions produce a value that can be worked with while procedures just “do” something which doesn’t directly affect the calling code.

Other languages don’t make a distinction and call both types procedures or functions and usually have a syntactic way to clarify the behaviour. However, it’s quite common that people distinguish although their programming language doesn’t. If you notice this just try to ignore that and don’t be confused.

The implementation of the Scheme programming language that is used by LilyPond is Guile 1.8. In this basically everything is considered a procedure, regardless of having a return value or not. Take the following expression:

(car '(1 2 3 4 5))

This expression is a procedure call, namely the call to the procedure car. The list '(1 2 3 4 5) is passed as the argument to car, which evaluates to 1, the first element of the list. So the “return value” that is then used in the program is 1. Other procedures, for example (display '(1 2 3 4 5)) do not evaluate to anything, so the “value” in the place of the procedure call is <unspecified>.

Both are called “procedure” in Guile’s terminology although one returns a value and the other does not. However, you will often encounter the naming convention of calling the “returning” versions “function”. This is actually against the official naming convention of the Scheme dialect that LilyPond uses, but it is quite common and doesn’t pose a real-world problem. And – as far as I can see – this is also true for the terms “music function”, “scheme function” and “void function”.

OK, let’s get back on track and consider the “return value” of our music function. Above I wrote that colorNote returns a music expression containing two overrides. But what does that actually mean?

The body of a procedure in Scheme is a sequence of expressions, and each expression can be either a value or a procedure call. The value of the last expression in the body is the value the whole function evaluates to – or, more colloquially, is the return value of the function. In the case of \colorNote this last expression is not a Scheme expression but a LilyPond music expression, as indicated by the #{ #}. From Scheme’s perspective this is a single value (of type ly:music?), but from LilyPond’s (or rather a user’s) perspective this music expression can also be a grouped sequence of music elements – in our example we have two consecutive overrides.

To conclude we can say that a “music function” is a procedure whose last expression evaluates to LilyPond-music. It can be called everywhere that you can write a music expression in LilyPond – just like in our initial example at the top of this post.

Now, what are scheme- and void-functions then?

The whole subject of defining these functions/procedures is identical to the definition and calling of music functions, the only (but crucial) difference is the return value. A procedure defined using define-scheme-function can return any valid Scheme value, and it can be used anywhere the respective Scheme value can be used. The following example takes a string as its argument and returns sort of a palindrome version (just for the sake of the example). The type of the return value is string?, and this can for example be used to set a header field.

addPalindrome =
#(define-scheme-function (parser location my-string)
     (ly:message "We will add the reverse of the string to itself")
     (string-append my-string (string-reverse my-string))

\header {
  title = \addPalindrome "OT"


The “body” of this procedure is a sequence of two expressions. The first one (ly:message prints something to the console output but doesn’t evaluate to a value, the second is the call to string-append, which is a procedure call that evaluates to a string.

Side note 1: Here again you can see an example of nested procedure calls and their evaluations: string-append here takes two arguments, the first being a value (namely the argument my-string), while the second argument is again a procedure call. The operations that Scheme actually performs one after another are:

(string-append my-string (string-reverse my-string))
(string-append my-string (string-reverse "OT"))
(string-append my-string "TO")
(string-append "OT" "TO")

So the nested expression in the first line of this example eventually evaluates to “OTTO”. And as this is the last expression in the procedure body its value will be the return value of the procedure as a whole, which in this example is used as the title of the score.

Side note 2: You can see that there is a single closing parenthesis on the last line of the procedure. This matches the opening paren in #(define-scheme-function. Scheme’s coding guidelines suggest not to place parens on their own lines but rather concatenate them at the end of previous lines. As you can already see in these simple examples nesting procedure calls can quickly build up, so it’s not uncommon to encounter Scheme procedures with, say, ten closing parens in the last line. However, I laid it out like this to explicitly show that each line in the example is one expression. Temporarily reformatting is a very useful tool for debugging procedures or to understand the structure of existing procedures you are looking at. Don’t hesitate to insert line breaks and make use of your editor’s assistance to re-indent the code as this will make things much clearer. Once everything is ready it’s advisable to re-compress the procedure again, even if you are used to other layouts that are common in other programming languages.

Probably you can by now guess what a void-function is – basically the same as the other two, but without a return value. So you will want to use define-void-function when you want the procedure to actually do something (also known as “side effects”) but don’t need any return value. The following example will print out a message to the console:

displayLocation =
#(define-void-function (parser location)
     (ly:input-message location "This was called from a 'void-function'")

There is just one expression in the function body, printing a message. In the case of define-void-function it doesn’t matter if this (respectively the last) expression evaluates to something or not, the function won’t return any value at all. This also has the effect that you can actually call void functions from anywhere. The parser won’t try to use them as a value but will simply execute its code. So the following example is equally valid and working.

displayLocation =
#(define-void-function (parser location)()
   (ly:input-message location "This was called from a 'void-function'"))


I hope this post helped you understanding a few basic things about how music, scheme, and void functions work and how they are integrated in LilyPond documents. This is only a tiny start, but understanding these concepts thoroughly definitely helps with proceeding to more complex and more powerful functions. As a final “assignment” I’ll leave it to you to figure out what the location does in the last example, how it is used and how its value actually got into the function.

by Urs Liska at April 20, 2015 12:54 PM

April 19, 2015


About Subscriptions

There are a number of recurrent questions about subscriptions to Ardour that come up. This article tries to collect them all and provide a coherent set of answers.

read more

by paul at April 19, 2015 02:26 PM

April 18, 2015

Libre Music Production - Articles, Tutorials and News

Ardour 4 is released!

Ardour has just seen a new major release, version 4. Since the last release, there have been over 4,000 commits.

Ardour has seen a lot of infrastructure work and now uses a new graphics engine (cairo) for the editor window. You can now also use other audio backends other than JACK, for example you could use ALSA, although JACK is still the recommended backend.

by Conor at April 18, 2015 11:08 PM


Ardour 4.0 released

The Ardour project is pleased to announce the release of Ardour 4.0. This release brings many technical improvements, as well as new features and over a thousand bug fixes.

The biggest changes in this release:

  • Better cross platform support. Ardour now runs on GNU/Linux, OS X and for the first time, Windows.
  • JACK is no longer required, making it easier than ever for new users to get Ardour up and running (though JACK is still usable with Ardour).
  • The user interface has seen a thorough overhaul, leading to a more modern and polished experience.

ardour 4.0

Read more below for a more detailed summary of the changes ...

read more

by paul at April 18, 2015 09:20 PM

Libre Music Production - Articles, Tutorials and News

OpenAV Release System : The End!

OpenAV have just released a statement announcing the end of the OpenAV Release System.

The idea of this system was that source code for OpenAV projects would be released 12 months after their announcement with donations bringing forward release dates 1 month at a time.

The full statement can be read on the OpenAV website. The accompanying video is below.

by Conor at April 18, 2015 09:16 PM


OpenAV Release System : The End!

OpenAV Release System : The End!

TL;DR: OpenAV will not use the OpenAV Release System for future projects. One year after the OpenAV Release System was presented at the ZKM, it is time to say goodbye. In the rest of the article will be explained how the OpenAV Release System has its drawbacks. So why is OpenAV no longer interested in the release system – it worked right!?… Read more →

by harry at April 18, 2015 06:33 PM

Hackaday » digital audio hacks

DIY Bass Drum Microphone Uses Woofer Cone As Diaphragm

Anyone into audio recording knows that recording drums is a serious pain. Mic setup and positioning can make or break a recording session. One particular hurdle is getting a great sound out of the bass drum. To overcome this, [Mike] has built a microphone using an 8″ woofer in an attempt to capture the low-end frequencies of his bass drum. Using a speaker as a microphone isn’t a new idea and these large diaphragm bass drum mics have taken commercial form as the DW Moon Mic and the now-discontinued Yamaha SubKick.

The project is actually quite simple. The speaker’s positive terminal is connected to Pin 2 of a 3-pin XLR microphone connector. The speaker’s negative terminal is connected to the connector’s Pin 1. [Mike] made a bracket to connect the woofer to a mic stand, which in turn was cut down to position the woofer at bass drum height. The setup is then plugged into a mixer or pre-amp just like any other regular microphone.

[Mike] has since made some changes to his mic configuration. It was putting out way too hot of a signal to the preamp so he added an attenuation circuit between the speaker and XLR connector. Next, he came across an old 10″ tom shell and decided to transplant his speaker-microphone from the open-air metal rack to the aesthetically pleasing drum shell. Check out [Mike’s] project page for some before and after audio samples.

Filed under: digital audio hacks, musical hacks

by Rich Bremer at April 18, 2015 05:01 PM

Create Digital Music » Linux

RME Do Compact Audio with 4X Analog, Digital, MIDI


There are plenty of fairly good audio interfaces out there. Decent-to-middling, yes. But if you’re picky about getting something really top-notch in terms of audio performance and stable low latency, that list gets a whole lot shorter.

Want it to be really compact? That list gets shorter still. “Pro” often translates to “rack mount” – but just because you want something light and small doesn’t mean you don’t want something serious.

RME is a brand that very often winds up on that short list. And their new BabyFace Pro I suspect ticks a lot of the boxes you want.

First, four is a very good number – as in four inputs, four outputs. A lot of boxes give you two of either of those, but that often finds you running out of I/O. Others give you more – which you often never use. Four inputs cover a lot of recording applications without needing a mixer. A separate headphone out means you can create listen to a monitor or cue mix, or simply have two more line out channels (say, for rear speakers).

And the BabyFace Pro has a lot of other stuff that other boxes leave out:
Digital (ADAT and S/PDIF).
Hardware meters (so you can actually see your levels easily).



Now, MIDI isn’t hard to come by, but it’s nice to have. The I/O configurations make loads of sense, too. You get headphone jacks for both mini and jack plugs – with both high and low impedance, for whichever cans you have handy. You get inputs for both line level and high impedance (for instruments). You get real XLRs for your mics, even though it’s compact. (Only outs 3/4 are on minijack, but that’s not really an issue, I think.) And the form factor is lovely.

The only disadvantage I can see is, it’d be nice to have four line outs and then headphones switchable to 1/2 or 3/4, which is not what you get here – so quad fans may want to go elsewhere.

The BabyFace Pro is a USB interface (USB2/USB3), but RME is one company that seems to get that right. They really do produce devices that can clock reliably, thanks to what they explain is smart jitter production, and I can’t think of a single brand that has their sterling reputation for low latency performance on OS X and Windows and iOS/mobile and (though they don’t mention this) Linux. (Speaking of Linux: a friend actually tried his Linux box on the Messe show floor and verified plug-and-play operation and terrific performance. And, hey, don’t you want to invest in a box that will work with everything?)


The marketing for this interface is a bit funny – with the slogan “reengineered, not remastered” and some pretty generous assumptions that customers will understand, for instance, why having an FPGA is important. But skipping that, I think this will top up that short list of really good audio interfaces. You can sign up now and they’ll let you know when it arrives.

The post RME Do Compact Audio with 4X Analog, Digital, MIDI appeared first on Create Digital Music.

by Peter Kirn at April 18, 2015 02:21 PM

April 16, 2015

Libre Music Production - Articles, Tutorials and News

Guitarix updates

Things have been moving along for the Guitarix project lately. First of all, they have redesigned their website and forum. Also, their website now has a new domain at, while the source code is still hosted at sourceforge.

by Conor at April 16, 2015 08:01 AM

April 15, 2015


Post LAC-2015

Post LAC-2015

Wow what a wonderful time at LAC – so many interesting projects, passionate developers and enthusiastic users. Once again, LAC has proven to be a fantastic place to talk with everybody, get all important user feedback, and last but not least – enjoy a beer with the linux audio community. AVTK presentation OpenAV presented on the AVTK UI toolkit, which… Read more →

by harry at April 15, 2015 12:24 PM

April 14, 2015

Libre Music Production - Articles, Tutorials and News

LAC 2015 photo gallery & videos now online

Thanks to Rui Nuno Capela and his trusty camera, you can now check out photos from this year's Linux Audio Conference. You will find the photo gallery over at

He has also uploaded videos of LAC's Linux Sound Night. You can check out these videos on Rui's youtube account.

by Conor at April 14, 2015 08:29 AM

Hackaday » digital audio hacks

Cyclist Pulled Over for Headphones Builds Neighborhood Shaking Bicycle Boombox

Riding around with headphones on is not the safest of things; those people are trying to could hit you! [Victor Frost] was actually pulled over for doing it. Although the bicycle police didn’t ticket him, they did push him over the edge to pursuing a compromise that lets him listen to tunes and perhaps still hear the traffic around him.

The build puts 200 Watts of audio on his rear luggage rack. He used a couple of file totes as enclosures, bolting them in place and cutting one hole in each to receive the pair of speakers. The system is powered by two 6V sealed lead-acid batteries which are topped off by a trickle-charger when the bike is parked.

Looking through this log we almost clicked right past this one. It wasn’t immediately apparent that this is actually version four of the build, and these are completely different spins each time. The top-down view of plastic-tacklebox-wrapped-v3 is sure to make you grin. Video overviews of the first two versions are linked in [Victor’s] details section of the project page linked at the top of this post. The progress is admirable and fun time digging through. They’re all quite a bit different but bigger, better, and more self-contained with each iteration.

Okay, okay, maybe this isn’t going to shake the neighborhood… until he adds a Bass Cannon to it.

Filed under: digital audio hacks, transportation hacks

by Mike Szczys at April 14, 2015 05:00 AM

April 10, 2015

Hackaday » digital audio hacks

Logic Noise: More CMOS Cowbell!

Logic Noise is an exploration of building raw synthesizers with CMOS logic chips. This session, we’ll tackle things like bells, gongs, cymbals and yes, cowbells that have a high degree of non-harmonically related content in them.

Metallic Sounds: The XOR

I use the term “Non-harmonic” in the sense that the frequencies that compose the sound aren’t even integer multiples of some fundamental pitch as is the case with a guitar string or even our square waves. To make these metallic sounds, we’re going to need to mess things up a little bit, and the logic function we’re introducing today to do it is the exclusive-or (XOR).

An XOR logic gate has two inputs and it outputs a high voltage when one, and only one, of its inputs is at the high voltage level. When both inputs are low or both inputs are high, the output of the XOR is low. How does this help us in our quest for non-harmonic content? It turns out that the XOR logic function is the digital version of a frequency mixer. (Radio freaks, take note!)

Ideal frequency mixers take two input frequencies and output the sum and difference of the two input frequencies. If you pipe in 155 Hz and 200 Hz, for example, you’ll get out the difference at 45 Hz and the sum at 355 Hz.

Because we’re using square waves and an XOR instead of an ideal mixer, we’ll also get other bizarre values like 2*155 – 200 = 110 Hz and 2*200 – 155 = 245 Hz, etc. All said, the point is that we get out a bunch of frequencies that aren’t evenly divisible by one another, and this can make for good metallic sounds. (And Dalek voices, for what it’s worth.)

The 4070: Quad XOR


Which brings us to our logic chip du jour. The 4070 is another 14-pin wonder, just like the 40106 and the 4069UB and the power and ground pins are in the same places. Since an XOR gate is a three-pin deal, with two inputs and one output, only four XORs fit on the 14-pin chip instead of six inverters.

By now, you’re entirely used to the 4000-series logic chips, so there’s not much more to say. This is a great chip to add sonic mayhem very easily to your projects.

Frequency Modulation with XOR: More Cowbell!

Let’s make some metallic noise. The first step is to mix two oscillators together. Whip up two variable-frequency oscillators on the 40106 as we’ve done now each time, and have a listen to each individually. Now connect each output to the inputs of one gate of an XOR in the 4070. As promised, the resulting waveform is a lot more complex than either of the two inputs.

Now tune them around against each other and listen to all the strange frequency components created as the sums and differences slide in and out. Cool, no? Here’s a bonus video that you can skip, but that demonstrates what’s going on with the frequency mixing.

Two-diode VCA

After a couple of minutes playing around, you’ll start to realize that this sounds nothing like a cowbell. We’ll need to shape the volume of the sound in time to get anywhere, and this means another step in the direction of “traditional” synthesizers. We’ll build up a ghetto voltage-controlled amplifier (VCA) and drive it with the world’s simplest envelope generator.

An active VCA takes its input signal and either amplifies or attenuates it depending on the control voltage (CV) applied on another input. When the control voltage is high, more of the sound gets through, and when the CV is zero, the output is ideally silent. Building a general-purpose VCA is a bit out of scope for our needs, so let’s just cobble something together with a few diodes.

This circuit works by cheating, and works best with digital logic signals like what we’ve got. When the input from the XOR is low, diode D1 conducts in its forward direction and all of the control voltage signal is “eaten up”, sunk into the output of the XOR chip.

Conversely, when the XOR is high, diode D1 is reverse-biased and blocks the CV, leaving it nowhere to go except through diode D2 and out to our amplifier. The resistor needs to be large enough that the XOR can sink all of its current, but otherwise the size is non-critical.

cap_square_to_pulesNotice what’s happened here. The voltage at the output is no longer the GND to VCC of our logic circuit, but instead ranges only from GND to the control voltage (minus a diode drop). So if we want to make a quieter version of the XOR input, we just lower the control voltage. It’s a simple voltage controlled attenuator. Now we just need to create a voltage signal that’s got something like the amplitude contour of a cowbell.

Remember how we converted square waves into trigger pulses by adding a series capacitor? The resulting voltage had this steep rise and exponential trail-off.

If we add in another capacitor, we can lengthen out the decay. And then while we’re at it, we can add in a potentiometer to control the rate of that decay.


Capacitor C1 converts the square wave into a pulse and charges up C2 very quickly, applying the positive voltage to the input of our VCA. The charge on C2 drains out through the variable decay potentiometer.

This simple circuit actually works well, but has one shortcoming. For long decay times, as illustrated above, the decay gets cut off when the control square wave goes low. If you only want short percussive hits, the simple circuit is enough. If you’d also like longer decays, you’ll need to add a couple diodes to chop off the negative part of the control voltage spikes.


Now that only periodic positive spikes are getting though to our decay capacitor, we have a nice variable-rate exponential decay voltage envelope. Here’s how it looks on the scope (with some extra capacitance slowing down the attack — envelope_with_xor_drumit might have been connected to the laptop soundcard). You can clearly see the control-voltage envelope chopped up by the diode action and the XOR’s output.

Putting the XOR frequency-modulated sounds through the two-diode VCA that’s driven by our quick and dirty envelope generator gets us a percussive metal sound.  But it it cowbell?  We still have to tune the oscillators up.

The classic, love-it-or-hate-it, cowbell sound of the 1980’s has to be the Roland TR-808. And if you look through the 808 service manual (PDF download) you’ll see that it uses two square waves from a 40106 chip simply mixed together. We’re improving on that by XORing, but we can still learn a bit from Roland. In particular, they tune their oscillators to 540 Hz and 800 Hz.

Because we’re XORing two oscillators together, our peaks come in at the sum and difference frequencies. This means that we’ve got to solve X + Y = 800 and X – Y = 540. Grab pencil and paper, or just believe me that you’ll want to tune up the individual square wave oscillators to 130 and 670 Hz respectively. At least, to get something like that classic cheesy cowbell sound.

Amplification Aside

We’ve been trying to stick to the use of purely CMOS logic chips here, but this session we broke down and used a transistor. The reason is that the audio input on our laptop insists on a bipolar, centered audio signal. In contrast, the output of our “VCA” sits mainly at zero volts with very short peaks up around one volt. The input capacitor in the laptop is charging up and blocking the VCA’s diode output. Boo!

Indeed, we can’t use our old tricks with the 4069UB as an amplifier here either. The 4069UB works great for signals that are centered around the mid-rail voltage, but distorts near either GND or VCC. Unfortunately, we’d like our quiet drum sounds to taper off to zero volts rather than the mid-rail, so we’ll have to use something else to buffer our audio with.


The solution is to buffer the output with something suited to this unipolar signal, and the simplest solution is a plain-vanilla NPN transistor hooked up as a common-emitter amplifier common-collector amplifier. This configuration is a very useful analog buffer circuit; it puts out almost the same voltage as the input, but draws directly from the VCC rail and will certainly handle any sound card’s input capacitor. We used a 2N3904, but a 2N2222 or BC548 or whatever will work just fine.


Cymbals and similar metallic percussion instruments were pretty tricky to synthesize in the early days of drum machines. Until the LinnDrum introduced sampled cymbals, most just used a shaped burst of white noise. The aforementioned TR-808 used six 40106 oscillators linearly mixed together to approximate white noise. Again, we’ll improve on that by running it all through XORs with the result being somewhere between many oscillators and pure noise depending on how you set the oscillators up.

The inspiration for this circuit is the fantastic Synbal project (schematic in PDF) from “Electronics & Music Maker” magazine in 1983. It’s a much more complicated affair than what we’re doing here, but if you look at the left-hand side of the schematic, that’s the core. (If you’re copying the Synbal’s fixed frequencies for the oscillators, note that he uses 0.01 uF capacitors and we use 0.1 uF caps. Divide the feedback resistors by ten accordingly.)

cymbals.schThe trick to the cymbal circuit is making a lot of oscillators. We’ll hook up six of them, finally fully fill our 40106 chip. Then combine any pair in an XOR, take the output of that XOR and combine it with another oscillator. You’ve now got a complex oscillator that’s used up three 40106 oscillators and two XOR gates. Repeat this with the remaining oscillators and XOR gates and you’re nearly done. Connect the final two XOR outs through resistors to the output.

As with the cowbell circuit, this circuit can be made to sound “realistic” by picking the different component frequencies just right and tweaking the decay. We think that it makes a pretty decent hi-hat sound with a couple of the oscillators pitched high (1 kHz and up). On the other hand, if you’re into noise music you can skip the VCA altogether and tune the oscillators to similar, low frequencies. You get a vaguely metallic, almost rhythmic machine drone. Not to be missed.


We’ve snuck it in under the guise of making a cowbell sound, but the quick-and-dirty VCA here is also useful for modulating most of the synth voices we made in the first few sessions. We went for a percussive attack by using a capacitor to couple the driving square wave to the VCA, but there’s no reason not to use a variable resistor in its place to charge up the capacitor more slowly. If you do this, note that the attack and decay potentiometers will interact, so it’s a little quirky, but what do you want for two diodes anyway? Also note that any other way you can think of delivering an interesting voltage to the junction of the two diodes is fair game.

The XOR-as-frequency-mixer technique is pretty great, but you can also get a lot of mileage by using the XOR as a logic chip. Combining different divided-down clock outputs (from a 4040, say) with XORs makes interesting sub-patterns, for instance. And we’ll get more use out of the XORs in two sessions when they’re coupled with shift registers.

Next Session

We’ve got a whole lot of possibilities by now. We’ve got some good, and some freaky, percussion voices. We’ve got a bunch of synthesizer sounds, and if you recall back to the 4051, we’ve got a good way to modulate them by switching different resistors in and out. It’s time to start integrating some of this stuff.

If you’re following along, your homework is to build up permanent (or at least quasi-permanent) versions of a couple of these circuits, and to get your hands on at least two 4017 decade counter chips. Because next week we’ll be making drum patterns and introducing yet one more way to make music.

Filed under: digital audio hacks, Featured, musical hacks, slider

by Elliot Williams at April 10, 2015 02:00 PM


Learning With Memory Mapping or Mind Mapping

Memory mapping is a powerful technique to stimulate your thoughts, and a memory power boost.
The technique starts by drawing associations on a piece of paper. first start with the key idea or word in the center and write close by the sub ideas, then connect these with a line.

This is a powerful memory enhancing technique because it operates on a number of levels at once

Diagramming information coverts the incoming mass of data into concepts and images that are meaningful to you.
It draws on the left-brain verbal, analytic abilities and the right brain spatial, visual abilities, reinforcing facts and data simultaneously in the memory circuits on both sides of the brain.
By jotting down key ideas and indicating connections between them, you personalize the data, arranging them in a way that is meaningful to you.
Because there is always space for further ideas and connections you are prodded to keep looking in new directions.
Since the key elements are all right there on one sheet it’s easier for you to see important connections.
Consciously processing the information– rather than passively listening or reading– makes it more likely you will remember it.

Conclusion: Memory or Mind mapping is a very efficient memory boosting technique that works by involving all senses. I used it in college where I had only one class C grade and mostly B+ and A+

by pete0verse at April 10, 2015 01:27 PM


Ardour on Windows: help make it real

Thanks to several years of slow and steady work, Ardour now compiles and runs on all versions of the Windows operating system. For several months, we've offered ready-to-run versions via our nightly build site . We're almost ready to release Ardour 4.0, which will make it the first major release of the program that could run on Windows. We'd love to see Ardour running on Windows more and more.

BUT ...

read more

by paul at April 10, 2015 01:49 AM

April 09, 2015


LAC 2015 – OpenAV talk :)

LAC 2015 – OpenAV talk :)

Hi All, A quick note that OpenAV will be talking about progress, projects, and AVTK at 10:45 German time (thats GMT+2). If you’re interested, do click in to the live-stream: AVTK + more talk Live Streaming link Questions can be posted via IRC using Webchat on Freenode. Will report back after LAC, Cheers!     Read more →

by harry at April 09, 2015 11:25 PM

Libre Music Production - Articles, Tutorials and News

Arduino and MIDI out


Note! We have received some concern about connecting "directly" from the Arduino to the MIDI in port of a HW synth. Although we have done this successfully with several different HW setups, note that LMP does not take any responsibility for any catastrophic results of this tutorial. In the next part of this tutorial, "Arduino and MIDI in", we will introduce the optocoupler.

by admin at April 09, 2015 11:28 AM

April 08, 2015


Rubik’s Cube and Memory Techniques, Little Journey,Loci

As a Rubik’s cube fan there is the need to memorize algorithms to solve the blessed cube. I used the loci and little journey memory techniques to memorize this algorithm for solving the top corners of the cube. The algorithm goes like this U R Ui Li U Ri Ui L, first the upper layer is turned one twist, then a right side move is needed followed by a top inverse then proceed by turning the left side counterclockwise one twist. The second part of the algorithm is the same as the first all for the second right inverse move and last move which is a left turn. Now you could say” why is it so hard to remember 8 moves?” Well,I guess it is not, but the point of this experiment was to apply some learned memory techniques and put them to the test. I decided to take a little journey through the apartment as such, by the door of the office look up U to the vent, Look right into the bathroom R, look down to the basket Ui, Walk left backwards into the hall way Li, Look up to the vent U, Look at Dusty’s cage Ri, Look down, Look at the table L. This completes the algorithm which is the standard method for solving the top corners as explained in the booklet 7 step solution that is sold with the 3x3x3 cube. Myself, I combine two methods the one in the booklet and one I picked up from You tube on the net by some Chinese dude. Ni hao!
have fun !

by pete0verse at April 08, 2015 01:07 PM

April 07, 2015


Sound Synthesis Visually Explained.

I remember sitting in front of the Commodore 64 around 82 as a kid, trying to figure out the modular synthesis operations possible. With its then quite advanced sound chip, a MOS technology 6581. But it’s better known as the SID 6581. I have been getting busy with some electronics and Arduino stuff lately I might just make myself a midi sound module or such based on that chip. Anyway, it was at that time a big feature one up for it’s intended market audience, the hobbyists. I was somewhat left to my own device to figure things out, mind you we didn’t have Internet then so a trip to the library was the best thing to do. To my chagrin they did not have a single book on hand. So I just did what I do and fiddled with some parameters and quite possibly invented New Wave or Emo doom! Hahaha good fun that was. But this schematic will sum it up greatly for you, know fire up that Oberheim Bristol plugin or the many classics available on Linux and throw some switches and turn those knobs!L06_a_overview-synthblock-01

by pete0verse at April 07, 2015 08:09 PM

Libre Music Production - Articles, Tutorials and News

LMP Asks #7: An interview with Giovanni A. Zuliani

This month we talked to Giovanni A. Zuliani, the founder and project manager of Giada LoopMachine, a minimal, hardcore audio tool for DJs, live performers and electronic musicians.

Hi Giovanni, thank you for taking the time to do this interview. Where do you live, and what do you do for a living?

I, along with my team live in Milan (northern Italy), working as a freelancer/IT consultant. Lately I’m doing a lot of web development, with pleasure I must say.

by Conor at April 07, 2015 06:54 AM

April 06, 2015

Libre Music Production - Articles, Tutorials and News

OpenAV ArtyFX 1.3 Call for testing

OpenAV have just put out a call for testing for the up and coming release of ArtyFX 1.3. The code is available on OpenAV's github repository right now for anyone interested in testing them out. Be sure to file any issues via github.

There are two brand new plugins added to the plugin suite. These are -

by Conor at April 06, 2015 03:48 PM


LAC Preparations

LAC Preparations

Its been a while since the last post – so its a good time to let you all know what OpenAV has been doing. Harry will be talking at the LAC about AVTK, Fabla2, and a general OpenAV update – tune in if it suits your timezome, streaming links will be posted at a later date! ArtyFX 1.3 The next… Read more →

by harry at April 06, 2015 12:14 PM

April 05, 2015


GStreamer News

Outreachy Internship Opportunity

GStreamer has secured a spot in the May-August round of Outreachy (former OPW). The program aims to help people from groups underrepresented in free and open source software getting involved by offering focused internship opportunities with a number of free software organizations twice a year.

The current round of outreachy internship opportunities is open to women (cis and trans), trans men, genderqueer people, and all participants of the Ascend Project regardless of gender. The organization plans to expand the program to more participants from underrepresented backgrounds in the future. You can find more information about Outreachy here.

GStreamer application instructions and a list of mentored projects (you can always suggest your own) can be found at the GStreamer-Outreachy landing page. If you are interested on applying to an internship position with us, please take a look at the project ideas and get in touch by subscribing to our development list and sending an email about your selected project idea. Please include [Outreachy 2015] in the subject so we can easily spot it.

GStreamer participation in this round of the program it's being sponsored by Samsung's Open Source Group. Deadline for applications is April 10.

April 05, 2015 06:00 PM

April 03, 2015

Scores of Beauty

Using Lilypond in the Platonic Music Engine

I have a music generating software project, written in Lua, called the Platonic Music Engine (PME). It started its life as a simple tool to be used by several other projects I’m working on but has gotten so out of hand that it has taken on a life of its own. It aims to do everything musical that can ever be done. Part of this goal is to be able to generate sheet music in a variety of styles which is where Lilypond comes in.

The PME operates by taking an initial input from the user like a name, a number, or any random string of characters and turns that string into a piece of music, a single melodic line. This music is not constructed with any conventional aesthetic ideas in mind. In fact it’s basically random. Technically it’s pseudo-random which means that the music is deterministically generated such that while the initial seed produces the same music each time, the results appear to be random. In the original incarnation of this project the PME was only going to quantize the score to make it playable on the instrument of the user’s choice while altering the musical qualities of the original music as little as possible (ie, it would still sound random).

A friend convinced me that producing random sounding music probably was not the way to gain a large enough following that would be willing to pay the bills. I reluctantly agreed and began adding what I call style algorithms to the software which allow the user to manipulate that initial piece into sounding like any style of music ever devised. Or it will, right now I’ve only programmed in a few style algorithms like one that creates a very simple Bach-like Invention, one that creates serial music, another that creates guitar chords, and others which you can see here.

In addition to producing music in a wide variety of styles it also generates sheet music for those pieces. It does several styles of graphic notation (using LaTeX) as well as standard notation using Lilypond. You can see examples of all of these here and below.

An example score produced by the PME using minimal quantization, ie, maximal random-soundingness. (click to enlarge)

An example score produced by the PME using minimal quantization, ie, maximal random-soundingness. (click to enlarge) for the sheet music above.

An example of a graphical score. This one is an adaptation of Feldman's graph notation based on the sheet music above. It makes use of an entirely optional dynamic shading feature where the the darkness (light, medium, and dark) matches the volume (soft, medium, and loud).

An example of a graphical score. This one is an adaptation of Feldman’s graph notation based on the sheet music above. It makes use of an entirely optional dynamic shading feature where the the darkness (light, medium, and dark) matches the volume (soft, medium, and loud). (click to enlarge)

In the first example above a “minimal amount” of quantization was used. But that isn’t exactly accurate. What this means is that I told the computer to take a piece of music that has more notes (128 possible notes vs the 88 that are available on a piano), greater range of durations (32767 possible values vs the 15 in use in the software), and more gradations in volume (128 vs 12 used in standard notation—ppppp to fffff) and squeeze it down to fit what an actual human can play on an actual instrument. For this example I told the computer to use the full range of values that it had available for this instrument and to treat them all equally. A more “aggressive quantization” would have been telling the software to “weight” some of those values like only using the notes in the C-Major scale and of those putting extra emphasis on the tonic and dominants and not use the supertonic at all. And then only using p, mp, mf, and ff along with just eighth, quarter, and half notes and then on top of all that only using the middle two octaves of the piano. The user has a near limitless variety of options that they can pass to the PME in order to quantize the initial music into sounding like whatever they desire and that’s before applying any actual style algorithms to it.

Using Lilypond with the PME

The PME, when called upon to, can generate a Lilypond file representing the music that it has generated. Getting it to do this hasn’t been an easy process. We are all used to having complete control over our Lilypond files in order to get the exact look we want. In this project the software has to produce perfect or nearly perfect results without any intervention at all. Users cannot be expected to edit the resulting Lilypond files themselves. This is especially the case when the PME goes live in an online version that allows anyone without any music experience to generate music.

The good news is that Lilypond is up to the task. In fact I cannot imagine any other program being able to meet this requirement. There are other text-based engraving programs but none that produce such polished output. And of course the usual suspects of programs that have graphical interfaces are of no use here.

In order to produce good results I have had to put quite a bit of effort into the process of generating Lilypond files. The rest of this post will discuss some of the details of this process.

An interesting default feature of Lilypond is that it does not automatically split notes and rests across bar lines. It is expected that you, as the person creating the Lilypond file, will manually indicate how and when notes are split. In the case of the PME, many of the style algorithms do not generate music that is actually written with a time signature in mind—it’s basically long cadenzas. But I decided that it looks better, and makes it easier to read, if there are bar lines anyway. The user is allowed to choose any time signature they want in most style algorithms, but because most of these style algorithms do not generate music with any time signature in mind this creates a problem. Lilypond will just put a note at the end of a measure, with its full duration, regardless of how little sense it makes.

Fortunately Lilypond also gives you the means to disable this feature and will split notes and rests across bar lines in a fairly sophisticated manner. You simply add the following code in your \layout section:

\layout {
  \remove "Note_heads_engraver" 
  \consists "Completion_heads_engraver"
  \remove "Rest_engraver" 
  \consists "Completion_rest_engraver" 

Now Lilypond will split your notes across bar lines.

An example score produced by the PME using minimal quantization, ie, maximal random-soundingness

The first two measure of the score above. The snippet on the left shows the default Lilypond behavior, the snippet on the right shows Lilypond automatically breaking notes across bar lines.

The PME will generate music for any instrument (that it has a definition for—right now this comprises the instruments making up general midi plus a few others) and tries its best to make sure the sheet music is appropriate for that instrument. Besides making sure the music fits the range of the instrument it also attempts to generate the sheet music using whatever is standard for that instrument including the proper clef and transpositions.

One aspect of making music look good and natural for an instrument is the judicious use of ottava markings. Because the PME does not allow us the privilege of manually altering the Lilypond code, we either have to do without ottava markings or figure out a way to automatically add them from within the software. Originally I wrote a lot of code to calculate good spots to insert ottava markings based on the octave of the pitch. Unfortunately it was very difficult to generate good results, either the marking would come in too late (the pitch too high above/below the staff) or too early and there was little I could do about it without devoting a massive amount of time and code to tracking additional data.

Fortunately the amazing Lilypond community came to the rescue. I posted a question about automatic ottava markings to the Lilypond list and while Lilypond has no such built in capability it does provide enough of a customizable framework via its Scheme scripting engine to add these kinds of features. In fact David Nalesnik very generously created a Scheme function that would automatically insert ottava markings based on the number of ledger lines used instead of the octave of the note which had been my approach. This Scheme function allowed me to rip out a significant amount of code that I no longer have to maintain and update when changes are made and the results look even better. You can find a download link for this function here and see it in action in the first image above.

Similarly, dealing with enharmonic spellings has been a huge headache. This involved multiple tables for different keys and root notes. And whenever fundamental changes were made to the underlying infrastructure, I had to update all the tables and the code that processed them. It was an even larger and more unwieldy mess than the ottava situation above.

And then while looking through the mail list I came across a post by Peter Gentry describing some work he had done extending an existing Scheme function dealing with automatic enharmonic spellings. We discussed the issue, with several other people, and he ended up creating a function that handles automatically forcing the appropriate enharmonic spelling for whatever key you’re in. Here’s a link to my gitlab project page where you can download his code.

With this function in hand I was able to rip out all of my code which would try to use the appropriate enharmonic spellings in the sheet music. As it stands now the PME only generates Lilypond code with sharps (and naturals) and the function determines if they should be flats instead and makes that change. This has improved my code tremendously and produces perfect results.

In this example the notes sent to Lilypond were all naturals and sharps and the script converted the sharps to the enharmonically equivalent flats. This example also shows more aggressive quantizing starting from the same source material as above. (click to enlarge)

In this example the notes sent to Lilypond were all naturals and sharps and the script converted the sharps to the enharmonically equivalent flats. This example also shows more aggressive quantizing starting from the same source material as above. (click to enlarge)

One final example of Lilypond’s functionality and then I’ll wrap this up. One of the style algorithms I created is basically a musical version of John Cage’s Mesostic (also see below for an example from Cage where he found the spine “James Joyce” in Joyce’s Finnegans Wake) method of generating poetry from a source text. My style algorithm creates a standard score and then “finds” famous melodies within it like the opening theme to Beethoven’s Fifth Symphony or the theme from Bach’s Toccata. The sound file plays the source music very softly and when the found melody notes occur it plays them loudly providing a kind of aural analogue to the typographic method Cage employed. But then I also wanted to have the score make the found melody clear. Lilypond colors the melody note red and depending on the style chosen either makes the melody note always appear at the beginning of its own line (acrostic), be somewhere in the middle of its own line (mesostic), or just be displayed following standard notation practice (standard). Implementing this was trivially easy and did not involve much more than adding the line

red_note = { 
  \once \override NoteHead.color = #red 
  \once \override Stem.color = #red 

to my Lua code and then inserting the command,\red_note, into the appropriate spot while the software generates the Lilypond file.

whase on the Joint
            aS you

   is a ffrinCh
        soracEr this is

(Mesostic created by John Cage using “James Joyce” as the spine and Finnegans Wake as the source text to search through.)

The Musical Mesostic style algorithm using the acrostic formatting. The spine is a rather famous motif. (click to enlarge)

The Musical Mesostic style algorithm using the acrostic formatting. The spine is a rather famous motif. (click to enlarge) rather famous musical motif should be audible above the rest of the music.

The Future and Final Thoughts

I am already anticipating certain challenges to come. One of which is a generic method of indicating microtones using any tuning including those that divide the octave into any number of divisions (eg, 128-EDO, 1,000-EDO, 3,728.31-EDO). My thoughts are that once we’re past what can be done with the normal accidentals (quarter sharps, triple quarter sharps, and ignoring enharmonic spellings) that there will need to be a new approach. One that I’ve successfully experimented with is creating accidentals that show the percentage distance from the base note to what it sounds like. So if a note is 18.4% of the way between its root note, G, and the next note, A, then the accidental would be something like “184″ arranged vertically and attached to the G. Not that this would be particularly useful for a musician or that any instrument exists that can play in 1,000-EDO tuning, but that the sheet music will be accurate and still look good. This is the Lilypond code I used in my tests:

  \override Accidental #'stencil = #ly:text-interface::print 
  c' e' 
  \once \override Voice.Accidental.text = 
  \markup { 
    \override #' (baseline-skip . 1.2) \teeny 
    \column {1 8 4} 
  gis' e'
Proof of concept for a new accidental style for microtones. This is a G that is 18.4% of the way between a G and an A.

Proof of concept for a new accidental style for microtones. This is a G that is 18.4% of the way between a G and an A.

More work will need to be done to make this method work really well but I feel like I’ve demonstrated that it can be done. (Now no one should be surprised when a post to the mail list shows up with some questions about how to tweak this code.)

I am happy with the graphical scores that I am producing with LaTeX but feel confident that I could also produce them in Lilypond using postscript (or some other method?). This would make formatting the headers and title pages much easier and if done in a general enough fashion could be useful for other Lilypond users. If someone wants to help me understand postscript and how to integrate it into Lilypond then I’d love to tackle that issue.

Additionally, any composer who would like to see their works adapted for the PME or any musician who has an interest in seeing the works of any composer of any style from anywhere in the world from any time similarly adapted, please contact me. I want to include every musical idea that has ever existed or will ever exist and I really enjoy the process of collaborating with others in making these things happen. An example here would be to take the very simple Bach-like Invention style algorithm I’ve done and replace it with algorithms that more closely match what Bach actually did, like an algorithm for each Invention. Basically if there’s any piece of music or musical style you’d like to see algorithmized I am up for it.

At the end of the day Lilypond has proven itself capable of generating beautiful scores automatically without any human intervention. My software creates a Lilypond file and with some specific choices made by me and plenty of help from the community (both answering my questions and generously providing new Scheme functions), the resulting sheet music is both accurate and beautiful.

I remain further convinced that there is simply no other engraving product available that can produce these results at this level of quality. And I also remain certain that no matter what issue I have a solution is available thanks to the wonderful Lilypond community and the hard work all the developers have put into making Lilypond the powerful and flexible product that it is.

David Bellows studied composition at various schools in East Tennessee. He has written music for the concert stage and gallery openings and of late has been taking private commissions. He is currently in Bellingham Washington, US, and is looking for a place to live.

by David Bellows at April 03, 2015 07:00 PM

Create Digital Music » Linux

Bitwig Studio as Instrumental Pack: Cristian Vogel, u-he Deals


Bitwig Studio turns one year old this week, and they’re keen to use the occasion to convince you to try their software. But the pitch takes a different angle, focusing more than ever on the particular bundle of instruments and effects. There’s an artist pack by Cristian Vogel that makes it clear what’s possible (hello, granular) — and, ending on the 7th of April, deals on U-he instruments to sweeten the pot.

For soft synth lovers, it might be a haul of Easter candy that convinces you to bite.

We’ve already talked about my affection for Cristian Vogel: he’s an artist with a uniquely expressive sonic character, manifested in thumbprints on all his musical output.

And in a new creation for Bitwig Studio, he confirms some of my suspicions of the best potential of that software. When Bitwig Studio came out, many looked to it to be some sort of new direction for DAWs, in particular relative to Ableton Live, which it closely resembles. But the software, for now, doesn’t differ so much from other tools on the market.

Where Bitwig seems to come into its own is with its instruments and effects. If you’re looking for a bundle of new sounds wrapped inside its particular production workflow, in other words, it begins to come into its own.

In Vogel’s capable hands, that’s what you hear – granular and other effects producing a particular digital sound, like the white-pebble ice storms we’ve been seeing in Berlin the last few days. Watch:

Here’s what he writes about his contribution:

I mostly like the way that it’s a kind of modular effects rack with a lot more possibilities than first meets the eye. Actually, if you’re into making patches or modular synths, then you’ll get it straight away. You can wrap elements inside of other elements and control many parameters with just one turn. Really, you can imagine and invent all sorts of things… pretty wild combinations.

So after a few late nights of patching stuff up using only the built-in FX modules and some samples from my own archives, of course, I started to come up with unique inventions: like a kind of Bitwig-only-style crazy granulator. It chops up samples into little grains which turn into long clouds that rain down into a quantized dust and gets frozen into rainbow icicles … sort of thing.




But Bitwig really want you to buy Bitwig Studio. And this week’s deal is pretty stellar, if you’re interested: you get u-he’s amazing ACE or Bazille free when you buy Studio this week.

Already own Bitwig Studio? There’s a US$50 gift voucher for you toward the purchase of any u-he plugin if you’re an existing user.

More on that developer:

Cristian Vogel artist pack:

And details on the plug-in deals and 1 year anniversary:

Are you using Bitwig Studio? Care to share impressions or tips? Let us know in comments.

The post Bitwig Studio as Instrumental Pack: Cristian Vogel, u-he Deals appeared first on Create Digital Music.

by Peter Kirn at April 03, 2015 03:58 PM

April 02, 2015


Do Something!

I'm a very opinionated person and I don't think that there is much I can do about that. Most of the time I try to not force my personal opinions on people, some of my friends and family might disagree, but I do honestly try. I like to think most people arrive at their opinions honestly and they represent a perspective, however different than mine, that is informed by things I might not be able to understand. I do know that my opinions on things have changed or maybe even evolved with time and I'd like to think we are all on a path headed towards our dreams. Maybe at different points on the path but still on a path. If I can help someone down the path with me, I try to do it. What I won't do is push someone to make ground on something by force.

In my own head I don't think I have a single personal philosophy that guides my life. Most of the time I feel like I'm drowning in my own self doubt. However, I do get put into the position of offering advice on peoples lives more than I'm comfortable with. Most of the time I just try my best to nudge people in a positive direction.

Lately however, I've been giving more and more thought to what I would call my personal brand of guiding wisdom. Now I obviously don't have the answer to eternal happiness, world peace or even how to not annoy the crap out of everyone by accident. The reality is, I'm pretty useless at making other peoples lives better most of the time, despite my grand ideas for changing the world.

What I do know is that when I'm at my most depressed or discouraged that I can always dig myself out. Even if it feels at the time like I never will. I don't have a magic silver bullet but I do know that every day I can chose to do at least one thing that makes my life or the life of those around me better and I think that mostly sums up my approach. As I've thought about it, I've boiled it down to something fairly concise.

"Do Something"

What I mean by that is you might not be able to control everything that happens to you and you also might not be able to control the way you feel about it. What you can do is move yourself down the path. Sometimes it's a moon surface leap and sometimes it's crawling through glass, but progress is progress. No, this won't guarantee your bills will get paid, you will save your marriage or heal a childhood pain. It might not even make you feel better. What it will do is put you a little closer, bit by bit.

If you are like me, most things feel overwhelming. I can be pretty hard on myself. I once told someone, "You can't say anything to me more hurtful than what I've said to myself." I think it might be one of the most honest things I've ever said. What I have found though that helps me more than anything, is doing something. Anything. As long as it's a positive step in the right direction. Even if it's just one small step with a million more to go, it's one step closer to my final destination.

No matter how small the gesture it can at least help you get into a better head space. It could be something for yourself, like getting chores you've been avoiding knocked out or something huge like finally telling someone how you care about them. You don't even have to do it for yourself. Sometimes when I'm at my lowest it helps to think about the things I wish others where doing for me at that moment and do it for someone else. One example is, for my own narcissistic reasons, I really like things I post to social media to get liked by my friends and family. Sometimes a post that I feel really strongly about or connected to will get almost completely ignored and it will send me into a tailspin of self doubt. In all likely hood there are multitudes of reasons people didn't take the time to click "like", and most are probably not related to me or my personal feelings. So, even in this silliest of first world problem situations, I try to reach out to others, click like on things my friends post or leave a positive comment. I would never do this disingenuously. I'm always clicking like or give a positive comment to something I actually like. I'm just trying to go a little more out of the way to make someone else feel good.

Now, does this achieve anything measurable. Most of the time no. Most of my friends are likely unaware I do this. Does it suddenly make all my neurotic obsession over whether people like me go away? not at all. What it does though is put me at least half a step closer to feeling better and more often than not it's enough to give me a clear head to see the next step I need to take. Sometimes that next step is one of those moon surface leaps that I can't believe I didn't take before.

Don't get me wrong, I don't hinge my day to day feelings on these silly little acts. Mostly I've learned about myself that I really like the feeling of creating something so I try to focus on those kinds of activities. I have loads of hobbies and things that I do that keep me moving forward. I think those count too. What I try not to do is sit around and think of all the things I should be doing and know for sure I won't do. I'd rather focus on the things I can do than the things I can't.

So now I think I can feel a tiny bit more comfortable in offering someone advice. Just "Do Something." As long as it's positive progress, it's worth it. No matter your situation, you can at least do something to make it better. No matter how insignificant it might seem at the time. I even keep a small daily journal where I try to write down the positive things I did that day. I also write some of the negatives but as long as there is at least one positive, it helps.


Do Something!

That's the best I've got.

by Daniel Worth ( at April 02, 2015 07:45 PM

April 01, 2015

Nothing Special

What a difference a new release makes (or: LTS vs Latest)

I've been sticking with Ubuntu's LTS releases since I got out of school mostly because I don't have the time anymore to do a monolithic upgrade and then fix everything it breaks afterward.  I've actually been championing them, because changing your whole system every 6 months is just asking for trouble. But I've been running 14.04 on this new Mac Book Pro at work and haven't been wowed by the hardware support. I think LTS is perfect for my 6 year old Thinkpad that has had full linux hardware support OOTB for 5 years or so, but with the latest greatest hardware, you need the latest greatest software.

As usual the kernel has a lot of driver improvements already, but using 3.13 or whatever kernel 14.04 was stuck on didn't have them. The machine was working enough to get my tasks done but I had wifi disconnects very very frequently, I can't hot swap mini-display ports for my second monitor, and several other inconveniences reign. I'd tried just updating the kernel in 14.04 but I think I needed to recompile glibc and/or a whole bunch of other things for it to really work and I haven't had time to go figure that out either. Amazing what I'll put up with just so I can use i3wm.

So yesterday I couldn't take it any more. I wanted some of those fixes in the recent kernels. So I did the monolithic upgrade to "Utopic". I did it through the terminal (sudo do-release-upgrade) and everything went quite smoothly. It took most of the day, but already I feel like it's better (placebo effect?). 14.10 is using kernel 3.16 and next month I'll go to 15.04 when its realeased which will have kernel 3.19 (which should at least fix thunderbolt/midi display hot swapping if I understand correctly).

Oops, spoke too soon. Wifi just dropped. (Which, by the way, happens to the guys actually running OSX on theirs too, we've got weird wifi issues at the office). So here's hoping 3.19 will be the bee's knees. Fingers crossed.

by Spencer ( at April 01, 2015 11:08 AM

March 31, 2015

Create Digital Music » open-source

Now littleBits Modules Play with MIDI, USB, CV: Videos


littleBits’ Synth Kit began as a lot of fun. Snap together small bare boards connected by custom magnets, and you can create basic synthesizers, or mix and match more exotic littleBits modules light light sensors. No soldering or cable connections are required.

But while you could use various littleBits components, your options were comparatively limited as far as connecting to other gear. That changes today with the release of new modules for MIDI, USB, and analog Control Voltage (CV), ranging $35-40 each.

There are three modules, each made in collaboration with KORG:

You can also buy a US$139.95 “Synth Pro Pack” that includes two of the CV modules, a MIDI module, a USB module, mounting boards, and cables.


Let’s look at the modules one by one, then see what they can do:



Costs US$39.95. This is the most useful of the three, to me, and the easiest no-brainer purchase if you’ve got a Synth Kit. You can route MIDI in and out of a littleBits rig to any other MIDI hardware – though you have to choose one or the other, by setting the single minijack to either “in” or “out.” And you can run MIDI in and out over micro USB to a computer. (The module operates driver-free, or you can install an optional driver from KORG – probably only if you’re on Windows would you want to do that.)

In effect, this module also works as a littleBits CV-to-MIDI converter, translating any analog input from a module to MIDI messages.

Applications: you can now use littleBits sensors or sequencers to play any MIDI instrument. Or you can play your littleBits rig using a MIDI controller or your computer sequencer.


Control Voltage

Cost: US$34.95. The CV module is basically the same idea, but with CV instead of MIDI. It couldn’t be simpler: you get one CV in, one out. Remember that CV connection for “littleBits” on KORG’s SQ-1 sequencer? Now we get to see it in action.

Now, because littleBits is already built around control voltages, this is a bit of fun. littleBits modules become a toolkit of various sensors and the like, as outputs to gear. And anything you have that generates control voltage – like a modular rig, for instance – now can be used to play synths you build with littleBits. Of the two, I suspect the former is more interesting than the latter, just because if you have a modular rig already, you can build something quite a lot more interesting and powerful than with littleBits. On the other hand, littleBits has all sorts of interesting motors and sensors, and if you don’t want to muck around with Arduino and the like, you can now snap together some strange sensors and quickly connect them to your modular rig with a $35 module.



Costs US$34.95. USB I/O handles just audio. But you can both route audio from your computer and to your computer. That makes it easier to record what you’ve made with your Synth Kit, if you don’t have an audio interface handy.

Also, because you can use an audio stream for control voltage, you can use the USB I/O kit to control modules.

So, in other words: the MIDI and I/O modules make it easier to integrate synths you’ve built with your computer and/or MIDI gear. The CV module I think will be most useful as a way of making strange new inputs for a modular synth.

Also interesting: today, littleBits has a bunch of partner videos showing off how these modules interoperate with other products. For instance, here’s Tony Rolando, of modular maker MakeNoise:

Or Peter Speer, showing some ideas for how to build interesting synths:

Patch ideas with the new littleBits Synth modules from Peter Speer on Vimeo.

Lysandre Follet shows how you might add a littleBits synth instrument to a larger Eurorack modular setup:

Icaro Ferre from Spectro Audio uses his software CV Toolkit to demonstrate how that powerful tool can be used to control other gear via CV. And… well, really, this is relevant to anyone interested in that software whether or not you want to use it with littleBits:

Cycling ’74 shows what they can do with Max/MSP:

Here’s a video Theremin:

And here’s the application I thought was sort of most cool, which is using the littleBits sensor modules to quickly interface with software:

More information:

Introducing: MIDI, CV, and USB I/O [littleBits Blog]



Bonus: It has nothing to do with littleBits – though it’s relevant to DIY. I love this DIY bow interface created by Peter Speer, which I stumbled across again while looking at him:

Euro bow interface prototype from Peter Speer on Vimeo.

The post Now littleBits Modules Play with MIDI, USB, CV: Videos appeared first on Create Digital Music.

by Peter Kirn at March 31, 2015 04:48 PM

March 30, 2015

Scores of Beauty

Managing Alternative Fonts with LilyPond

Oh my, it’s been quite some time since my last post – fortunately there has been at least a guest post recently and there are more in the pipeline. I have been working hard under the hood and there are exciting things going on, but nothing was in a state to be presented here. Now finally I can break the silence and write about one of the topics, at the same time providing some glimpses into other parts of current development in LilyPond’s ecosystem.

As you know (if not: it was announced in “LilyPond’s Look & Feel”) Abraham Lee has enabled LilyPond to use alternative notation fonts, and he already has provided an impressive range of fonts with various styles that are available from In a two part series I’ll introduce you to this new world of stylistic variety that has become possible through Abraham’s work and that openLilyLib makes easily accessible now.

Today we’ll take a first tour through LilyPond’s font handling in general – as it has originally been designed, as it has been until now, and as it will be from now on. In the next post I’ll take the presentation of “Arnold”, a new font Abraham created upon my suggestion, as an opportunity to dig slightly deeper into this topic and show you the tools provided by openLilyLib in some more detail.

Accessing Alternative Fonts – Then and Now

As mentioned in my earlier announcement LilyPond wasn’t originally designed to use alternative fonts, and this was one of the more severe limitations with LilyPond. When I had the opportunity to talk with representatives of several major publishing houses the option of integrating custom fonts to achieve their house styles was one of the first questions that usually arose. When Simon Tatham created the first available replacement font one had to actually exchange the font files so LilyPond wouldn’t even notice that the font had changed. This is a somewhat hacky and non-trivial approach that is described on the font’s home page.

As of Lilypond 2.19.12 this changed, and for the current stable version 2.18 there is a reasonably simple patch to make it work. Now there is a single function available to select any compatible notation font that has been copied to LilyPond’s font directories. The following example simply shows the default values.

\paper {
  #(define fonts
      #:music "emmentaler"
      #:brace "emmentaler"
      #:roman "Century Schoolbook L"
      #:sans "sans-serif"
      #:typewriter "monospace"
      #:factor (/ staff-height pt 20)

This syntax allows you to choose which fonts to change and which ones to leave at these default values, so the following would be sufficient to switch the notation font (general and brace) to the LilyJAZZ font:

\paper {
  #(define fonts
      #:music "lilyjazz"
      #:brace "lilyjazz"
      #:factor (/ staff-height pt 20)

The process of getting and using the alternative fonts is described in detail on the documentation page on However, getting the fonts to be recognized in the first place is still a little bit awkward, as you can’t simply “install” the fonts to your operating system but have to copy them inside LilyPond’s own font folders. Concretely you have to:

  • Download the archive file for a font from the website
  • Extract it to disk
  • Copy the font files from two folders to two folders inside your LilyPond installation

As this depends on the actual LilyPond installation you’ll have to repeat that step for any additional LilyPond installation you may have (and developers can have numerous different builds in parallel to test different features), and also you’d have to repeat this every time you update LilyPond. The issue can be slightly alleviated by creating symbolic links instead of physical copies inside the LilyPond installations – yet this has to be done again each time too.

Accessing Alternative Fonts – The Future

Well, all of this was yesterday – but the future is bright :-) .
Keeping your collection of alternative fonts up-to-date has become a breeze now, and using these fonts has become much simpler and even more powerful as well, thanks to two of my latest projects.

Automating Font Management

With install-lily-fonts managing a repository of alternative fonts has become a near-automatic process. This tool maintains a local repository and a catalog of fonts and versions and uses this to automatically detect any new or updated versions on the server. It then downloads new archives if necessary and “installs” them to one or multiple LilyPond installation(s). So regularly running this program (at least after updating or installing LilyPond versions) is all you need to make sure that you always have the complete and newest set of alternative fonts available for use with LilyPond! I think this should really encourage anybody to experiment with and use this newly available stylistic variety in music engraving.

So far I haven’t prepared an official “binary” release or included it into a Python repository, and I haven’t had the opportunity to incorporate this functionality in Frescobaldi (any help with this would be greatly appreciated). But you can download/clone/fork the tool from its repository on Github. Please visit that site for a more detailed description too.

Note: unfortunately I haven’t got any assistance yet to deal with this process on Windows too. So I assume that currently the program only works on Mac and Linux. If anyone has experience with handling symbolic links (or circumventing the need for that) on Windows with Python I’d be more than happy to accept help to make the tool available for all.

A New Library To Use Alternative Fonts

Now that we have the set of fonts available we also want to actually use them in scores. I’m pleased to tell you that this has become even more simple and powerful with the new interface provided by openLilyLib. Today I’ll only give you a short “teaser” about this, and in the next post I’ll go into more detail and present you the new functionality as well as differently styled engraving examples.

The original idea of setting up openLilyLib had been to have a place to store snippets of useful LilyPond code, similar to the official LilyPond Snippet Repository but not depending on a specific LilyPond version and having a Git interface for easier collaboration. Quite soon it was improved as to be includable – you can directly \include modules from openLilyLib instead of having to copy & paste code from the LSR and integrate that into your own files. But right now openLilyLib is undergoing a fundamental redesign, and the new Font Interface I’m presenting today is part of it. So you will see examples of the new way of using LilyPond extensions, but I won’t go into any detail about that new infrastructure as it is not ready for a general release and proper announcement (of course the readers of Scores of Beauty will be the first to know about any breaking news ;-) ). All you have to know now is that in order to use the new font interface you need the latest version of openLilyLib and make its root directory and the ly directory inside available to LilyPond’s include path.

The following code, inserted at the top of the input file, will change the notation font to the Improviso font:

\include "openlilylib"
\useLibrary Stylesheets
\useNotationFont Improviso
Improviso default appearance (click to view PDF)

Improviso default appearance (click to view PDF)

  • The first line loads the general openLilyLib infrastructure, and I think putting this at the top of the input file will become a second nature for most, just as it is a no-brainer to start each file with a \version statement.
  • The second line loads the “Stylesheets” library – the new openLilyLib is organized around the concept of coherent libraries. The “Stylesheet” library so far only implements the font stuff but we plan to do much more with it in the not-too-distant future.
  • The last line finally switches the notation and the brace font to Improviso.

Maybe you noticed that the example doesn’t look like LilyPond’s default output with just the font replaced? Well, this is part of the additional horsepower I promised and that we’ll take a closer look at in the next post. So stay tuned …

Investigating installed fonts

So you know how easy it is to switch the notation font to one of the numerous alternatives that are available by now. But what if you just don’t have the list of installed fonts at your fingertips? Well, you might go to the font website to have a look, or you might investigate LilyPond’s font folder (if you know where this is). But fortunately openLilyLib provides a much more convenient way, and this is the last item for today’s post before I let you wait for the next post with more details and examples about the new fonts. As you may already guess the “Stylesheets” library provides a command for that purpose:

\include "openlilylib"
\useLibrary stylesheets

which will produce something similar to the following on the console:

Installed notation fonts:
- arnold
- beethoven
- cadence (no brace font)
- emmentaler
- gonville
- gutenberg1939
- haydn
- improviso
- lilyboulez (no brace font)
- lilyjazz
- paganini (no brace font)
- profondo
- ross
- scorlatti (no brace font)
- sebastiano

OK, next time we’ll see more examples and you’ll get the opportunity to taste some of the power that lies in the new infrastructure of openLilyLib. Controlling the wealth of new styles with a simple interface is just what makes life continuously easier with LilyPond. I always pointed out “programmability” as a unique advantage of text based systems. You may want to have a look at the underlying programming work that makes all this possible, so you can read the source code. The beauty of LilyPond is that such elaborate functionality can be made available for the “end user” with such elegant simplicity as \useNotationFont Improviso

by Urs Liska at March 30, 2015 07:37 PM

Libre Music Production - Articles, Tutorials and News

Audacity 2.1.0 Released

Version 2.1.0 of Audacity, the free audio editor and recorder, was just released. Here are some of the improvements:

by Eduardo at March 30, 2015 01:14 PM

Create Digital Music » Linux

Free Audacity Audio Editor Gets Spectral Edits, Live Plug-ins


Dedicated wave editor Audacity has found enduring popularity, as a free and open source tool for working with sound. It runs on Linux, Windows, and OS X – with support for older Mac operating systems, which these days is sometimes tough to find. But just being free and open isn’t reason enough to use something, particularly when a lot of DAWs do a pretty decent job of wave editing.

This latest version of Audacity, 2.1.0, comes with some additions that might make it worth revisiting.

First, there’s spectral editing. In most software, audio editing is performed by time only. Here, you can drag over particular frequency ranges to select just those portions, for audio repair or simply highlighting certain portions of sonic content. That’s been available in some commercial tools, but it’s not normally found in DAWs and now you get it for free. See the spectral selection additions to the manual.

Second, you can now preview VST and Audio Unit effects (plus the open LADSPA format) in real-time. That’s useful for making Audacity an effect host, and can combine nicely with chains and batch processing. That is, you can preview effects live to adjust them (as you can do in a DAW) and then batch-process a bunch of sound (which your DAW can’t do easily). Plug-in hosting in general is improved, including the ability to work with multiple VST and add any effects to chains.

There’s also a new Noise Reduction effect.

Audacity still isn’t the prettiest software ever (ahem) – aesthetically and functionally, it seems the UI is due for a reboot. But I know it’s an important tool, especially for musicians on a budget. And this version is worth adding to your toolset.

Need another reason to use Audacity? How about the fact that the extreme time shifting capabilities of Paulstretch are built right in?

Check out the Audacity download page:

(Manual links there are broken as I write this, so you can use my links above for that.)

Also worth considering is ocenaudio (note “ocen,” not “ocean”!):

It isn’t as full-featured as Audacity – real-time effects preview is limited to VST, for instance, and the spectral view is not editable. It’s also free-as-in-beer; the code is closed. But the UI is substantially cleaner, and it has some nice features like multi-edit support. Thanks to Tom D in comments for the tip.

The post Free Audacity Audio Editor Gets Spectral Edits, Live Plug-ins appeared first on Create Digital Music.

by Peter Kirn at March 30, 2015 12:00 PM

Libre Music Production - Articles, Tutorials and News

Q-stuff release frenzy

Rui Nuno Capela has been on a pre-LAC2015 release frenzy with his Q-stuff suite of software. In the past week he has released updates for QjackCtl, Qsynth, Qsampler, QmidiNet, QmidiCtl and of course Qtractor. You can find full details about these releases over at

by Conor at March 30, 2015 06:40 AM

March 29, 2015

Qtractor 0.6.6 - The Lazy Tachyon is out!

And finally, for the wrap of the pre-LAC2015@JGU-Mainz release party, no other than the crown jewel of the whole Qstuff bunch ;)

Qtractor 0.6.6 (lazy tachyon beta) is out!

Release highlights:

  • LV2 and VST plugins GUI position persistence (NEW)
  • MIDI clip editor record/overdub note rendering (FIX)
  • VST plugin recursive discovery/search path (NEW)
  • VST-shell sub-plugins support (FIX)
  • also some old and new lurking bugs squashed.

Qtractor is an audio/MIDI multi-track sequencer application written in C++ with the Qt4 framework. Target platform is Linux, where the Jack Audio Connection Kit (JACK) for audio and the Advanced Linux Sound Architecture (ALSA) for MIDI are the main infrastructures to evolve as a fairly-featured Linux desktop audio workstation GUI, specially dedicated to the personal home-studio.

Flattr this


Project page:



Qtractor is free, open-source software, distributed under the terms of the GNU General Public License (GPL) version 2 or later.


  • MIDI clip record/reopen to/from SMF format 0 has been fixed.
  • LV2 and VST plugins GUI editor widget position is preserved across hide/show cycles.
  • Added application description as's AppData.
  • Added a "Don't ask this again" prompt option to zip/archive extrated directory removal/replace warning messages.
  • MIDI clip editor (aka. piano-roll) gets lingering notes properly shown while on record/overdubbing.
  • Current highlighted client/port connections are now drawn with thicker connector lines.
  • Fixing segfaults due to QClipboard::mimeData() returning an invalid null pointer while on Qt5 and Weston.
  • Return of an old hack/fix for some native VST plugins with GUI editor, on whether to skip the explicit shared library unloading on close and thus avoid some mysterious crashes on session and/or application exit.
  • Force reset of plugin selection list when any of the plugin search paths change (in View/Options.../Plugins/Paths).
  • Recursive VST plugin search is now in effect for inventory and discovery on path sub-directories (VST only).
  • Non-dummy scannig for regular VST, non-shell plugins, were doomed to infinite-loop freezes on discovery, now fixed.

Enjoy && keep the fun.

by rncbc at March 29, 2015 04:30 PM

Libre Music Production - Articles, Tutorials and News

Calf 0.0.60 Released!

The Calf team have just announced the release of version 0.0.60 of the very popular Calf Studio Gear plugins.

There are many bug fixes, new plugins as well as new features.

There are 16 new plugins included in this release, bringing the total number of Calf plugins up to 45. The new plugins are as follows -

by Conor at March 29, 2015 03:56 PM

New release of Giada Loop Machine

Version 0.9.5 of Giada Loop Machine has been released. This version, codename 'Nabla Symbols', has a number of refinements, as well as permanent MIDI mapping.

by Conor at March 29, 2015 03:42 PM

Recent changes to blog

J Hendrix Fuzz Face

Today is raining here, so I play around with our Ampsim toolkit.
Well, lets try to emulate the Fuzz Face of J. Hendrix, I said to myself.
First step is to create the schematic of the unit.
Here it is:

Fuzz Face

Now, create a (python) build script to generate faust source code
with our DK simulator in our Ampsim toolkit.

import os
from analog import *

schema = "Fuzzface2.sch"
path = "tmp"
module_id = "fuzzface"
mod = os.path.join(path, module_id+".so")

# create plugin
c1 = Circuit()
c1.plugindef = dk_simulator.PluginDef(module_id) = "Fuzz Face"
c1.plugindef.description = "J Hendrix Fuzz Face simulation"
c1.plugindef.category = "Distortion" = "fuzzface"

and yep, start guitarix and found the new plug in the Distortion category. Wow, sounds great. That will be enough for me to play with today. :D

Maybe the one or the other will try it, no problem, it's in the guitarix git repository allready.
And for those how use faust by themselves, here is the resulting faust source:

 // generated automatically
declare id "fuzzface";
declare name "Fuzz Face";
declare category "Distortion";
declare description "J Hendrix Fuzz Face simulation";


process = pre : iir((b0/a0,b1/a0,b2/a0,b3/a0,b4/a0,b5/a0),(a1/a0,a2/a0,a3/a0,a4/a0,a5/a0)) with {
    LogPot(a, x) = if(a, (exp(a * x) - 1) / (exp(a) - 1), x);
    Inverted(b, x) = if(b, 1 - x, x);
    s = 0.993;
    fs = float(SR);
    pre = _;

        Volume = 1.0 - vslider("Volume[name:Volume]", 0.5, 0, 1, 0.01) : Inverted(0) : LogPot(0) : smooth(s);

        Fuzz = 1.0 - vslider("Fuzz[name:Fuzz]", 0.5, 0, 1, 0.01) : Inverted(0) : LogPot(0) : smooth(s);

    b0 = Fuzz*(Fuzz*(Volume*pow(fs,3)*(4.76991513499346e-20*fs + 5.38351707988916e-15) + pow(fs,3)*(-4.76991513499346e-20*fs - 5.38351707988916e-15)) + Volume*pow(fs,3)*(-4.76991513499346e-20*fs + 5.00346713698171e-13) + pow(fs,3)*(4.76991513499346e-20*fs - 5.00346713698171e-13)) + Volume*pow(fs,2)*(-5.05730339185222e-13*fs - 1.16162215422261e-12) + pow(fs,2)*(5.05730339185222e-13*fs + 1.16162215422261e-12);

    b1 = Fuzz*(Fuzz*(Volume*pow(fs,3)*(-1.43097454049804e-19*fs - 5.38351707988916e-15) + pow(fs,3)*(1.43097454049804e-19*fs + 5.38351707988916e-15)) + Volume*pow(fs,3)*(1.43097454049804e-19*fs - 5.00346713698171e-13) + pow(fs,3)*(-1.43097454049804e-19*fs + 5.00346713698171e-13)) + Volume*pow(fs,2)*(5.05730339185222e-13*fs - 1.16162215422261e-12) + pow(fs,2)*(-5.05730339185222e-13*fs + 1.16162215422261e-12);

    b2 = Fuzz*(Fuzz*(Volume*pow(fs,3)*(9.53983026998693e-20*fs - 1.07670341597783e-14) + pow(fs,3)*(-9.53983026998693e-20*fs + 1.07670341597783e-14)) + Volume*pow(fs,3)*(-9.53983026998693e-20*fs - 1.00069342739634e-12) + pow(fs,3)*(9.53983026998693e-20*fs + 1.00069342739634e-12)) + Volume*pow(fs,2)*(1.01146067837044e-12*fs + 2.32324430844522e-12) + pow(fs,2)*(-1.01146067837044e-12*fs - 2.32324430844522e-12);

    b3 = Fuzz*(Fuzz*(Volume*pow(fs,3)*(9.53983026998693e-20*fs + 1.07670341597783e-14) + pow(fs,3)*(-9.53983026998693e-20*fs - 1.07670341597783e-14)) + Volume*pow(fs,3)*(-9.53983026998693e-20*fs + 1.00069342739634e-12) + pow(fs,3)*(9.53983026998693e-20*fs - 1.00069342739634e-12)) + Volume*pow(fs,2)*(-1.01146067837044e-12*fs + 2.32324430844522e-12) + pow(fs,2)*(1.01146067837044e-12*fs - 2.32324430844522e-12);

    b4 = Fuzz*(Fuzz*(Volume*pow(fs,3)*(-1.43097454049804e-19*fs + 5.38351707988916e-15) + pow(fs,3)*(1.43097454049804e-19*fs - 5.38351707988916e-15)) + Volume*pow(fs,3)*(1.43097454049804e-19*fs + 5.00346713698171e-13) + pow(fs,3)*(-1.43097454049804e-19*fs - 5.00346713698171e-13)) + Volume*pow(fs,2)*(-5.05730339185222e-13*fs - 1.16162215422261e-12) + pow(fs,2)*(5.05730339185222e-13*fs + 1.16162215422261e-12);

    b5 = Fuzz*(Fuzz*(Volume*pow(fs,3)*(4.76991513499346e-20*fs - 5.38351707988916e-15) + pow(fs,3)*(-4.76991513499346e-20*fs + 5.38351707988916e-15)) + Volume*pow(fs,3)*(-4.76991513499346e-20*fs - 5.00346713698171e-13) + pow(fs,3)*(4.76991513499346e-20*fs + 5.00346713698171e-13)) + Volume*pow(fs,2)*(5.05730339185222e-13*fs - 1.16162215422261e-12) + pow(fs,2)*(-5.05730339185222e-13*fs + 1.16162215422261e-12);

    a0 = Fuzz*(Fuzz*fs*(fs*(fs*(fs*(-3.73292075290073e-29*fs - 1.05633134620746e-20) - 3.11506369039915e-14) - 2.30719916990074e-11) - 1.07493164710329e-9) + fs*(fs*(fs*(fs*(3.73292075290073e-29*fs + 1.01643277726662e-20) + 2.91602352831988e-14) + 2.29636966370042e-11) + 1.07449105454163e-9)) + fs*(fs*(fs*(3.98985774247549e-22*fs + 1.99042653510896e-15) + 1.83615604104971e-13) + 5.31230624730483e-11) + 2.44402781742033e-9;

    a1 = Fuzz*(Fuzz*fs*(fs*(fs*(fs*(1.86646037645036e-28*fs + 3.16899403862238e-20) + 3.11506369039915e-14) - 2.30719916990074e-11) - 3.22479494130986e-9) + fs*(fs*(fs*(fs*(-1.86646037645036e-28*fs - 3.04929833179984e-20) - 2.91602352831988e-14) + 2.29636966370042e-11) + 3.22347316362488e-9)) + fs*(fs*(fs*(-1.19695732274265e-21*fs - 1.99042653510896e-15) + 1.83615604104971e-13) + 1.59369187419145e-10) + 1.22201390871017e-8;

    a2 = Fuzz*(Fuzz*fs*(fs*(fs*(fs*(-3.73292075290073e-28*fs - 2.11266269241492e-20) + 6.2301273807983e-14) + 4.61439833980148e-11) - 2.14986329420657e-9) + fs*(fs*(fs*(fs*(3.73292075290073e-28*fs + 2.03286555453323e-20) - 5.83204705663976e-14) - 4.59273932740084e-11) + 2.14898210908325e-9)) + fs*(fs*(fs*(7.97971548495099e-22*fs - 3.98085307021793e-15) - 3.67231208209942e-13) + 1.06246124946097e-10) + 2.44402781742033e-8;

    a3 = Fuzz*(Fuzz*fs*(fs*(fs*(fs*(3.73292075290073e-28*fs - 2.11266269241492e-20) - 6.2301273807983e-14) + 4.61439833980148e-11) + 2.14986329420657e-9) + fs*(fs*(fs*(fs*(-3.73292075290073e-28*fs + 2.03286555453323e-20) + 5.83204705663976e-14) - 4.59273932740084e-11) - 2.14898210908325e-9)) + fs*(fs*(fs*(7.97971548495099e-22*fs + 3.98085307021793e-15) - 3.67231208209942e-13) - 1.06246124946097e-10) + 2.44402781742033e-8;

    a4 = Fuzz*(Fuzz*fs*(fs*(fs*(fs*(-1.86646037645036e-28*fs + 3.16899403862238e-20) - 3.11506369039915e-14) - 2.30719916990074e-11) + 3.22479494130986e-9) + fs*(fs*(fs*(fs*(1.86646037645036e-28*fs - 3.04929833179984e-20) + 2.91602352831988e-14) + 2.29636966370042e-11) - 3.22347316362488e-9)) + fs*(fs*(fs*(-1.19695732274265e-21*fs + 1.99042653510896e-15) + 1.83615604104971e-13) - 1.59369187419145e-10) + 1.22201390871017e-8;

    a5 = Fuzz*(Fuzz*fs*(fs*(fs*(fs*(3.73292075290073e-29*fs - 1.05633134620746e-20) + 3.11506369039915e-14) - 2.30719916990074e-11) + 1.07493164710329e-9) + fs*(fs*(fs*(fs*(-3.73292075290073e-29*fs + 1.01643277726662e-20) - 2.91602352831988e-14) + 2.29636966370042e-11) - 1.07449105454163e-9)) + fs*(fs*(fs*(3.98985774247549e-22*fs - 1.99042653510896e-15) + 1.83615604104971e-13) - 5.31230624730483e-11) + 2.44402781742033e-9;

by brummer at March 29, 2015 01:12 PM

March 28, 2015 »

Wolfson Audio Card for Raspberry Pi

Just ordered a Wolfson Audio Card for Raspberry Pi via RaspberryStore. I asked them about this audio interface at their stand during the NLLGG meeting where I did a presentation about doing real-time audio with the RPi and they told me they would ship it as soon as it would become available. They kept their word so I'm hoping to mount this buddy on my RPi this very week. Hopefully it will be an improvement and allow me to achieve low latencies with a more stable RPi so that I can use it in more critical environments (think live on stage). It has a mic in so I can probably set up the RPi with the Wolfson card quite easily as a guitar pedal. Just a pot after the line output, stick it in a Hammond case, put guitarix on it and rock on.

Wolfson Audio Card for Raspberry Pi

by Jeremy at March 28, 2015 05:18 PM

March 27, 2015

Libre Music Production - Articles, Tutorials and News

LAC 2015 program

This years Linux Audio Conference will be getting underway in just under two weeks time. The conference runs from April 9th to 12th and will be taking place in Mainz, Germany.

You can now check out the program for the conference over at the LAC website. Don't forget, if you have any questions, you can hop onto the the LAC2015 IRC channel.

by Conor at March 27, 2015 08:58 AM

March 26, 2015

Libre Music Production - Articles, Tutorials and News

Musescore 2.0 Released

After over four years of development and a lot of work from over 400 contributors, MuseScore 2.0 is finally available! You can download it from

by Eduardo at March 26, 2015 03:15 PM

Hackaday » digital audio hacks

SNES Headphones Cry for Bluetooth Has Been Answered

A year and a half ago we ran a post about a SNES controller modified into a pair of headphones. They were certainly nice looking and creative headphones but the buttons, although present, were not functional. The title of the original post was (maybe antagonistically) called: ‘SNES Headphones Scream Out For Bluetooth Control‘.

Well, headphone modder [lyberty5] is back with a vengeance. He has heeded the call by building revision 2 of his SNES headphones… and guess what, they are indeed Bluetooth! Not only that, the A, B, X and Y buttons are functional this time around and have been wired up to the controls on the donor Bluetooth module.

To get this project started, the SNES controller was taken apart and the plastic housing was cut up to separate the two rounded sides. A cardboard form was glued in place so that epoxy putty could be roughly formed in order to make each part completely round. Once cured, the putty was sanded and imperfections filled with auto body filler. Holes were drilled for mounting to the headband and a slot was made for the Bluetooth modules’ USB port so the headphone can be charged. The headphones were then reassembled after a quick coat of paint in Nintendo Grey. We must say that these things look great.

If you’d like to make your own set of SNES Bluetooth Headphones, check out the build video after the break.

Filed under: digital audio hacks, nintendo hacks

by Rich Bremer at March 26, 2015 08:01 AM

March 25, 2015

QjackCtl 0.3.13, Qsynth 0.3.9, Qsampler 0.3.0 released!

The pre-LAC2015 release frenzy continues... ;)

Now for the next batch...

QjackCtl - A JACK Audio Connection Kit Qt GUI Interface

QjackCtl 0.3.13 is out.

QjackCtl is a simple Qt application to control the JACK sound server, for the Linux Audio infrastructure.



  • Added application description as's AppData.
  • Setup dialog form is now modeless.
  • Introducing brand new active patchbay reset/disconnect-all user preference option.
  • Current highlighted client/port connections are now drawn with thicker connector lines.
  • New user preference option on whether to show the nagging 'program will keep running in the system tray' message, on main window close.
  • Connections lines now drawn with anti-aliasing; connections splitter handles width is now reduced.
  • Drop missing or non-existent patchbay definition files from the most recent used list.

Flattr this

Qsynth - A FluidSynth Qt GUI Interface

Qsynth 0.3.9 is out.

Qsynth is a FluidSynth GUI front-end application written in C++ around the Qt4 toolkit using Qt Designer.



  • Added application description as's AppData.
  • New user preference option on whether to show the nagging 'program will keep running in the system tray' message, on main window close.
  • Application close confirm warning is now raising the main window as visible and active for due top level display, especially applicable when minimized to the system tray.
  • A man page has been added.
  • Translations install directory change.
  • Allow the build system to include an user specified LDFLAGS.
  • Czech (cs) translation updated (by Pavel Fric, thanks).

Flattr this

Qsampler - A LinuxSampler Qt GUI Interface

Qsampler 0.3.0 is out.

Qsampler is a LinuxSampler GUI front-end application written in C++ around the Qt4 toolkit using Qt Designer.



  • Added application description as's AppData.
  • Added this "Don't ask/show this again" option to some if not most of the nagging warning/error message boxes.
  • Mac OS X: Fixed default path of linuxsampler binary.
  • When closing qsampler and showing the user the dialog whether to stop the LinuxSampler backend, set the default selection to "Yes".
  • Master volume slider now getting proper layout when changing its main toolbar orientation.
  • Messages standard output capture has been slightly improved as for non-blocking i/o, whenever available.
  • Adjusted configure check for libgig to detect the new --includedir.
  • A man page has beed added (making up Matt Flax's work on debian, thanks).
  • Translations install directory change.
  • Added support for SF2 instrument names/preset enumeration.
  • Added instrument list popup on channel strip which shows up when the instrument name is clicked. Allows faster switching among instruments of the same file.
  • Adjusted configure check for libgig to detect its new --libdir (impolitely forcing the user now to have at least libgig 3.3.0).

Flattr this


QjackCtl, Qsynth and Qsampler are free, open-source software, distributed under the terms of the GNU General Public License (GPL) version 2 or later.

Enjoy && have some fun!

by rncbc at March 25, 2015 06:30 PM

Hackaday » digital audio hacks

Logic Noise: Filters and Drums

Filters and Drums

Logic Noise is an exploration of building raw synthesizers with CMOS logic chips. This session, we continue to abuse the 4069UB as an amplifier. We’ll turn the simple unity-gain buffer of last session into a single-pole active lowpass filter with a single part. (Spoiler: it’s a capacitor.)

While totally useful, this simple filter is a bit boring and difficult to make dynamic. So we’ll look into an entirely different filter, the Twin-T notch filter, that turns out to be sharp enough to build a sine-wave oscillator on, and tweakable enough that we’ll make a damped-oscillator drum sound out of it.

Here’s a quick demo of where we’re heading. Read on to see how we get there.


Last session, we built an amplifier and played around with the gain: the ratio of how much voltage swing is output relative to how much is input. An active filter is an amplifier where this gain depends on the frequency of the incoming signal. This lets us carve out different frequency ranges that we’d either like more or less of. (In general, though, you don’t need an amplifier to filter. See passive filters versus active filters.)

When you pluck a string on a guitar, for instance, all sorts of frequencies are produced. But over time the string vibrations are damped out by the wood that the guitar is made of, and within a half-second or so, most of the vibrations left are related to the string’s fundamental vibrational frequency (determined by where your finger is on the frets). The higher frequency vibrations are the first to go. This suggests a sound synthesis strategy to make “natural” sounding instruments: generate all sorts of frequencies and then filter out the higher ones.

Single-pole Lowpass Filter

Given that we’ve already made a few simple amplifier circuits last time, it’s a quick step to understand the simplest of all filters: the single-pole filter. Here’s the circuit diagram:


Yeah, that’s an added capacitor. That’s all there is to it. But have a listen to the difference:

Remember the intuition about the negative-feedback amplifier from last time. We had two resistors, one between the input and the 4069, and the other in feedback between the (inverted) output and the input. When the input voltage wiggled around the 4069’s neutral voltage, the output wiggled in the opposite direction. And the ratio of the voltage swings, the gain, depends on how hard the feedback path has to work to cancel out the incoming signal current.

The same intuition works for the filter, as long as you understand one thing about capacitors. Capacitors pass current through them only reluctantly. The amount of current a capacitor passes before it’s “charged up” to a voltage that resists any further incoming current is referred to as its capacitance. Or, in electro-math: C = Q/V or V = Q/C, where Q is the charge on the capacitor, which is also the current (charge per second) summed up over time.

In short, the more charge you put into a capacitor, the higher voltage it develops to resist putting more charge into it. And how quickly this voltage ramps up is proportional to one over the capacitance and directly proportional to the current passing through.

For us, this means that it’s easy to pass a given current through a capacitor for a short while, harder to pass the same current through for a longer time, and impossible to get current through forever without increasing the input voltage to overcome the capacitor’s “charged-up” voltage. Or put another way: capacitors let high frequency current vibrations through easily, resist middle frequencies, and deny constant-voltage direct current.

So what happens when we put a capacitor in the feedback path of our unity-gain feedback amplifier? Since the capacitor nearly blocks very low frequencies, all of them have to pass through the resistor, and we get unity gain. As we increase the frequency, some of the current starts to pass through the capacitor and the total feedback resistance is lowered. This means that the output has an easier job cancelling out the input, and thus less gain at middle frequencies. At very high frequencies, the capacitor will pass currents so easily that almost none will even need to go through the resistor, and the gain drops even lower.

Put more succinctly, the capacitor resists lower frequencies more than higher ones. In a negative feedback amplifier, output gain increases when it’s harder to push current through the feedback path. So by putting a capacitor in the feedback path, we make an amplifier with more gain in the low frequencies and less gain for higher frequencies. Voila, a lowpass filter!

Variable Cutoff Lowpass Filter

What if we want to vary the cutoff frequency? In math, the cutoff frequency for a single pole lowpass filter like this is 1/(2 * pi * R * C). Practically, we can vary the cutoff frequency by changing the capacitor or by changing the input current through the resistor. So we’ll set the basic range by picking a capacitor value and vary the filter’s frequency response by turning a potentiometer. For the circuit here, the cutoff frequency ranges from 160 Hz at 100k ohms to 1600 Hz at 10k ohms.

But there’s one catch with varying the input resistor; we also change the overall gain which depends on the ratio of feedback resistor to input resistor. So if you’re going to be changing the frequency response by changing the input resistor a lot, you might also want to change the feedback resistor at the same time to track it, holding the overall (passband) gain roughly constant. For that, you’ll need a stereo / dual potentiometer, which is simply two potentiometers linked to the same shaft. With one knob, you control two identical resistors.

Before we leave the single pole filter, you can convert the lowpass filter here into a highpass filter simply by moving the capacitor out from the feedback loop and sticking it in front of the input resistor. Give it a shot!

Twin-T Filter

Our story gets significantly more interesting if we toss a more complicated filtering element in the feedback path, and one of our favorite filters is the Twin T. Instead of being a lowpass filter like the one above, the Twin T is a notch filter. Notch filters pass both high and low frequencies, but are tuned to knock out a particular frequency in the middle.

In its raw form, the Twin T filter is fairly useful for killing a specific nuisance frequency in a signal. Maybe you want to knock out power line noise (60Hz in the USA, 50Hz in Europe). Toss a Twin T filter that’s tuned to 60Hz into the chain, and you’ll get rid of most of the noise without damping down the rest of your signal very much. To see why it’s called a Twin T, have a look at the circuit diagram:


The Twin T works by combining two signal paths, each one T-shaped. The T with two resistors and a capacitor to ground is a simple lowpass filter, essentially a passive version of the one we made above. The other T with the series capacitors and resistor to ground is a highpass filter.

Highpass and lowpass sounds like everything should get through, right? Yes, but. At the frequency that the filter is tuned for (the “cutoff” frequency) the two outputs are exactly 90 degrees out of phase from the input, but in opposite directions. In theory, if both Ts are tuned to the same frequency the two paths exactly cancel each other out at the cutoff frequency and none that cutoff frequency makes it through at all. In reality, you can actually get the two branches fairly close to each other and get very good, but not perfect, cancellation of the tuned frequency.

What happens when we put a Twin T filter into the feedback path of an amplifier? Remember that the negative feedback logic requires the output to create more voltage the harder it is to push current back through the feedback path. So instead of knocking out the frequency that the filter is tuned to, we get that one particular frequency amplified. If there’s a little bit of noise entering the input at our tuned frequency, it’ll get amplified a lot and all of the other frequencies will get attenuated. And suddenly you’ve got a sine-wave oscillator.


Which brings us to today’s killer circuit, and a little bit of a refinement on the above explanation. The short version is that we detune the Twin T filter a little bit so that it only rings when it’s given an impulse and then dies out.

First let’s play a little bit and build up the Twin-T and 4069UB amplifier part of the circuit. It’s just the Twin-T filter from above set up in the feedback path of a 4069UB inverter stage, and then sent out directly through another 4069UB inverter as a buffer. It’s overdriven and you’ll hear the clicks of the trigger bleeding through, but it’s a start.



With the basic circuit working, let’s expand on it in two different ways. First, we’ll drive the drum with another oscillator circuit. Then, we’ll pass the audio out through a lowpass filter to knock off some of the trigger pulse bleedthrough.

Here’s the final circuit:


Starting on the left, we have a very low frequency oscillator set up on the 40106 and buffered using another 40106 stage. This simply puts out a nice reliable square wave. The signal then passes through a capacitor, which again has the effect of letting only the higher frequencies pass through. What makes it through looks basically like a quick pulse (in green).


The trigger signal pulse is inserted into the feedback loop of the Twin T. It’s actually not crucial where you attach the trigger, but it’ll couple less with the Twin T section if you connect it here.

And finally, we’ll pass the signal through a lowpass filter to remove the clicky noise that comes from the raw trigger signal feeding through to the output.


What values should we use for capacitors and resistors? Try to pick the component values so that the single capacitor in the lowpass T is twice as large as the two capacitors (2 C) and the single resistor is half as large as the paired resistors (1/2 R). This makes both Ts tune to the same frequency, given again by 1/(2*pi*R*C) where R and C are the values of the paired resistors and capacitors respectively.

In practice, try to get factor-of-two capacitors and leave the resistors adjustable wherever possible. Since we’ll be de-tuning the circuit on purpose to make the oscillations die out slowly, there’s not a reliable formula for the resistances. You’ll just have to pick capacitors and tweak the knobs until it works. That said, if you find you want frequencies outside of the range that you’re currently getting, don’t hesitate to swap out the capacitors.

Tweaking and Tuning

Detuning the Twin-T section is the secret to making this circuit work as a drum rather than as a sine-wave oscillator, and the approach you’ll have to take is a bit experimental, so let’s talk about tuning this circuit. If you align the two halves of the Twin T perfectly, as we mentioned before, only the one single frequency will be blocked, and thus only that one frequency will be amplified by the negative feedback circuit. You’ll get a very nice sine wave oscillator, but not drums.

If you detune the two halves of the Twin T from each other, especially if you do so by raising the cutoff frequency of the highpass filter so that it’s higher than the lowpass filter, a wider and wider band of frequencies are blocked by the Twin T, and thus receive the extra gain from the amplifier.

But as you spread the gain over a wider and wider band of frequencies, you get less gain at any given frequency. As you continue to detune the Ts from each other, you’ll reach a point where the circuit no longer amplifies any single frequency enough to oscillate indefinitely by itself. However, and this is the key here, the filter will oscillate for a while if you provide it with a strong enough impulse signal. And that’s exactly what we’re doing with the square wave coupled through the capacitor coming from the tempo oscillator. It’s nice to watch the damped waveforms on a scope if you’ve got one.


So here’s a procedure for getting close to your desired sound. To enable oscillation over a wide range of frequencies, set the decay potentiometer as low as it will go. This sets the highpass leg of the T to a very high cutoff frequency, which means that it’s passing nearly nothing. This frees up the lowpass T section to determine the pitch, and for most of the tuning potentiometer’s range you’ll get oscillations. Pick the rough pitch you want by listening to the oscillator. Now you can tune up the decay pot until the oscillations are just damped out and you’ll be set.

But notice that the two potentiometers influence each other a little bit. That’s because the two legs of the T are simply electrically connected. So as you increase the decay to go from oscillator to drum, be ready to also tweak the frequency potentiometer to keep the drum tone at your desired pitch and decay rate.


If you’re interested in exploring more active filter designs than just the single pole lowpass shown here, have a look at Rod Elliott’s great writeup on active filters. You can either break down and use op-amps and dual power supplies, or you can keep hacking and replace any of the op-amps in his circuits with a 4069UB stage as long as they only use negative feedback and have the op-amp’s positive terminal connected to ground. In particular, have a look at the multiple feedback topology and the biquad.

If you don’t need synth drums, you can simply tune the Twin T up and use the circuit as a sine wave oscillator. For a single set of capacitors it’s not very widely adjustable, but if all you need is a single frequency you can pick the right capacitors and you’re set. It’s not the best sine wave oscillator out there, but it’s hard to beat a one-chip build with a few passive components thrown in.

But don’t take our word for it: here’s a scope shot. The yellow line is the produced sine wave, and the purple is a FFT of the signal. Vertical bars are 20dBV, or a factor of ten. The first peak, at 150Hz is our sine wave, and the second peak is down in voltage by about a factor of 100. It’s not lab equipment, but it’s pretty solid for the abuse of a CMOS logic chip.


And there’s nothing stopping you from feeding the circuit with audio-frequency trigger pulses if you want to freak out. The result is very similar to the sync oscillator we built before but it’s a lot mellower because the waveforms involved are fundamentally sine waves here.

Have fun!

Filed under: digital audio hacks, Featured, musical hacks

by Elliot Williams at March 25, 2015 02:01 PM

Scores of Beauty

Schemellis Gesangbuch

This month, March 2015, marks J.S.Bachs 330th birthday. For the occasion, the Pirate-Fugues team has published a new edition of 4-voiced transcriptions of the songs from Schemellis Musicalisches Gesang-Buch, BWV 439–507. LilyPond is among the tools in our production pipeline.

Some of the arias in Georg Christian Schemellis song book are fairly well known, for instance: Ich steh an deiner Krippe hier, BWV 469, and Komm süsser Tod, BWV 478.

Each original score from the collection consists of 2 voices:

  • a soprano voice with lyrics, and
  • a bass voice with Generalbass notation.

Here is an example: The first few measures of Mein Jesu, was für Seelenweh, BWV 487


In order to create a 4-voiced transcription, we add 2 voices in between the 2 existing ones. The resulting score could look something like


Transcriptions of these songs already exist. So what is special about our edition? Our goal was to create the 4-voiced transcriptions as faithful as possible to J.S.Bach’s own musical style. And, we want the computer to help us do it. Our composition approach is data-driven: Our custom made software harvests patterns from over 1700+ digitized scores by J.S.Bach.

The process is not fully automated, and we don’t think this is desirable anyways. Instead, the software computes between 10–30000 suggestions of up to 3 measures in duration. The suggestions are readily sorted according to intuitive mathematical criteria such as

  • voice coverage,
  • number of notes,
  • frequency of note constellations in database.

These and other categories allow the user to filter and narrow down the numerous possible insertions in a convenient and meaningful way.

The creative process usually takes 15–45 minutes for an entire song and requires a lot of user interaction. The video is only a summary to illustrate what the computed suggestions look like for the song BWV 487 already introduced above:

Note that, the sequential start-to-finish fashion is only to make the video align with the music. During the composition phase, the user can choose to edit the score in any order.

Before we elaborate on the role of LilyPond in our publication, we wrap up the description of the project:

Our software has a unique set of requirements:

  • the music notation (as shown in the video) requires precise control over the note placement in order to prevent jerkiness when browsing the suggestions;
  • extra information is drawn into the score: selected pitch range for computation, available pitches in the suggestions;
  • user interaction with the mouse filters and narrows down the suggestions.

No prior API was available to perform these tasks. So instead, we developed our own and called it The Pirate Fugues.

The audio for the collection of 69 songs is synthesized using 3rd party software Pianoteq, Ivory II, and Hauptwerk (all trademarked!, and to none of which we are affiliated). For each song, we provide an animation that visualizes the suggestions by our software and indicate the local correlation of the final score to the database. The website of our project is where you can listen to the results, download the sheet music, and find additional information on the technique.

Disclaimer: Faithful to J.S.Bach’s style is a bold claim and one that invariably sparks controversy. Although we have taken great care in compiling each score in the collection, there is room for improvement. Apart from creating the music, another objective of the project was to learn about the strengths and weaknesses of the software. Independent of your background in music, feel free to let us know what you think. Thank you!

Now, back to LilyPond:

We have introduced LilyPond to our workflow about 2 years ago. From Lilypond, we have adapted

  • the chord notation,
  • the ornament labelling and graphics, as well as
  • the Mensur note apparel.

Since then, all scores from our projects are algorithmically exported LilyPond for on-screen preview, and ready-to-print pdfs. We are not aware of any alternative to LilyPond that is as convenient and yields results of the same visual quality.

In the future, we hope that notation software like LilyPond will be able to imitate the handwriting of famous composers such as J.S.Bach.

by datahaki at March 25, 2015 08:01 AM

March 23, 2015

QmidiNet 0.2.1, QmidiCtl 0.2.0 released!

The pre-LAC2015 pre-season has just been started!

Here goes the first batch... ;)

QmidiNet - A MIDI Network Gateway via UDP/IP Multicast

QmidiNet 0.2.1 released!

QmidiNet is a MIDI network gateway application that sends and receives MIDI data (ALSA-MIDI and JACK-MIDI) over the network, using UDP/IP multicast. Inspired by multimidicast and designed to be compatible with ipMIDI for Windows.


Project page:


Flattr this

QmidiCtl - A MIDI Remote Controller via UDP/IP Multicast

QmidiCtl 0.2.0 released!

QmidiCtl is a MIDI remote controller application that sends MIDI data over the network, using UDP/IP multicast. Inspired by multimidicast ( and designed to be compatible with ipMIDI for Windows ( QmidiCtl has been primarily designed for the Maemo enabled handheld devices, namely the Nokia N900 and also being promoted to the Maemo Package repositories. Nevertheless, QmidiCtl may still be found effective as a regular desktop application as well.


Project page:


Flattr this


  • Reset (to network defaults) button added to options dialog, which also gets some layout reform.
  • Added application description as's AppData.
  • Previously hard-coded UDP/IP multicast address ( is now an user configurable option.
  • A man page has beed added. (QmidiCtl backlog)
  • Allow the build system to include an user specified LDFLAGS. (QmidiCtl backlog)


Both QmidiNet and QmidiCtl are free, open-source software, distributed under the terms of the GNU General Public License (GPL) version 2 or later.

Cheers && Enjoy!

by rncbc at March 23, 2015 06:30 PM

March 21, 2015

Libre Music Production - Articles, Tutorials and News

Libre Music Production tutorial features in Linux Format!

Libre Music Production's tutorial, "Ultimate Guide to Getting Started With Guitarix" is featured in this month's issue of Linux Format, out now! (Issue 196, April 2015)

This is our second time to feature in Linux Format. We'd like to again thank Neil Mohr and all at Linux Format for making this happen!

by Conor at March 21, 2015 06:48 PM

March 20, 2015

Hackaday » digital audio hacks

Auto-sleep Hacked in PC Speakers

We can commiserate with [HardwareCoder] who would rather not leave his PC speakers on all the time. The Creative T20 set that he uses turn off when you turn the volume knob all the way down until it clicks. So shutting them off means repositioning the volume each time they’re switched on again. This hack kills two birds with one stone by turning on and off automatically without touching that knob.

The system is based around an ATtiny45 and a few other simple components. It uses two ADCs to monitor the rear input channels of the PC speakers. If no sound is detected for more than one minute, the shutdown pin of the speakers’ amp chip is triggered. That’s not quite where the hack ends. We mentioned it monitors the rear input of the speakers, but it doesn’t monitor the front AUX input. An additional push button is used to disable the auto-sleep when using this front input. There is also a fancy PWM-based heartbeat on an LED when the speakers are sleeping.

[HardwareCoder] was worried that we wouldn’t be interested in this since it’s quite similar to a hack we ran a few years ago. We hope you’ll agree it’s worth another look. He also warned us that the demo video was boring. We watched it all anyway and can confirm that there’s not much action there but we embedded it below anyway.

Filed under: ATtiny Hacks, digital audio hacks, peripherals hacks

by Mike Szczys at March 20, 2015 05:00 AM

March 18, 2015

Libre Music Production - Articles, Tutorials and News

Libre Music Production Workshop in Barcelona

Andrés Pérez López is planning a workshop in Barcelona promoting free and open source software for making music. It will also feature some material published here on Libre Music Production. The workshop is planned to take place in CC Convent de Sant Agustí from 22nd April to 20th May. The program for the workshop is as follows -

by Conor at March 18, 2015 05:08 PM

Carla 2.0 beta4 is here!

Carla has just seen it's fourth beta release. This release is mostly focused on bug-fixing but there are some interesting new features.

The highlights are:

  • Updated plugin skins
  • New experimental plugins
  • MOD GUI Support

Also of note is a new MIDI sequencer plugin. This is experimental and in it's early stages but it is an interesting addition all the same.

by Conor at March 18, 2015 04:59 PM


Requiem for a Hero: Part II

A politician is a fickle thing, it changes allegiances as quickly as a wind blown $5 bill changes hands. Ownership means nothing to it. The crime bosses liked the systems of prohibition on certain common street drugs, it allowed their prices and profits to reach almost limitless heights. It fed the machinery that really ruled the world. The machinery, however, still has not found a solution to the problem it finds most troublesome. In spite of all it's efforts it still relies on the fickle voter to vote against their own best interest as they have done since they where given the gift of voting. Thankfully most the time the voter seems to have a deep-seated need to self sabotage, and only in very rare circumstances will they vote against the machinery that really runs the world. So it was a very rare case with the legalization of a certain common street drug. Enough voters had grown tired of the oppression and crime the drug's prohibition brought on the world and voted for the legalization. In response to the change in voter sentiment , and because a politician can change their allegiances in response to anything, the politicians all had very important meetings and collectively came to the conclusion it would be in everyone's best interest, mostly their own, to not fight the law. The result was a lot of temporarily unhappy criminals and a lot of tax revenue. The wind of popular opinion had blown the politicians into their own dark alley and on top of their own trash pile and they always did their best work in these types of situations.

The tax revenue from the now legal common street drug was, as decided by the voters, allotted to be used for the city's underfunded schools. This, of course, did not happen. The machinery that really ran the world hated schools. Schools teach people to vote in their own best interest. This is something that the machinery would never let happen. So the politicians found clever ways to divert the money to the recently upset criminals as a way to make up for having not prevented the voters from voting in their own best interest and so everyone, who mattered to the machinery, was happy.

Who wasn't happy where the future voters and current children at the local underfunded school. One of whom was the daughter of a recently deceased local hero that had been killed, unbeknownst to her, by a local crime boss. The daughter didn't even know her father was a hero. To her he was just another parent, preoccupied with the machinery that really ran the world and not very interested in the day to day dealings of his family's operation.

The daughter of the recently deceased local hero did well in her underfunded school. She always tried her hardest in everything she did. She was a good student, athlete, friend and daughter. She ate healthy, and in contrast to the other future voters and current children at the local underfunded school, she didn't drink sugary soda made from the chemically processed byproducts of inedible corn. She in every way lived up to the impeccable moral code of her recently deceased local hero father. She worried about the environment, and because of this she didn't  use disposable water bottles. She had written a report for a class at her underfunded school that the plastic from the disposable water bottles would pollute the local waterways of the city and that as an alternative everyone, like her, should carry a reusable water bottle with them. She took her ecologically friendly water bottle with her every where and filled it during the short period of time between classes at the water fountains in her underfunded school.

Unfortunately for the daughter of the recently deceased local hero, and the city, it was too late for the local waterways. They had all ready been polluted by the toxic and unfortunate side effect of a local business. The CEO of the company responsible for the dumping of the toxic and unfortunate side effect had recently been arrested and convicted of violating EPA regulations by illegally dumping substance and thus polluting city's local waterways. The representatives for the machinery that really ran the world asked him nicely to step down as CEO, pay a fine and spend 3 months in a local minimum security prison. The minimum security prison was much nicer than the other prison in the city that was mostly filled with the users of a formerly illegal common street drug. Most of whom suffered from formerly treatable chemical imbalances in their brain that had, at one time, been easily treated with prescription medication.

Little did the daughter of the recently deceased local hero know that her body didn't seem able to deal with the  toxic and unfortunate byproduct of a local business that had been dumped, illegally, into the local water ways and was now present in the drinking fountains of the underfunded school with which she filled the ecologically friendly water bottle she always had with her. Her young and athletic body was rapidly turning weak and frail like that of an old woman. She now possessed the kind of body that $5 worth of calories would make the difference between another week of living and escaping into the dark abyss of non-existence.

When the chief of police had told the daughter of the recently deceased local hero that her father was missing and presumed dead the daughter cried her toxic laden tears, fainted and crumpled out of her chair onto the floor. It was all too much for her frail body to take. The chief didn't even have time to give his well rehearsed speech about how they didn't have any solid leads in the case but that he would personally see to solving the matter and bring peace and justice to her and her family. Instead an ambulance took the daughter to a local hospital where she was placed on life support in a room next to a homeless man being treated for a variety of afflictions related to his homelessness.

The homeless man had an imbalance of brain chemicals that he self medicated with a now legal common street drug. While it was now legal to buy and use the common street drug it was not legal to use it in the street where the homeless man lived. So he had been arrested by the local police. He was being cleaned up and treated for his medical conditions, except of course the brain chemical imbalance, and would soon be transferred to a holding cell while he awaited conviction and sentencing to a local prison. He had no chance of going to the prison where the former CEO was serving his 3 month sentence for the illegally dumping of a toxic and unfortunate side effect of his former company's business.

The imbalanced chemicals in the homeless man's brain told him he would never make it in prison and that he would be better off in the dark abyss of non-existence. So when the nurse turned out the light and left him alone in his room to sleep he used a cord from the lamp in his hospital room to make his transition. So too did the girl in the the next room who was the daughter of the now deceased local hero and who's  frail body could no longer stand the strains of the toxic and unfortunate substance it had running through it. She joined the homeless man and her hero father in the dark abyss of non-existence.

A journalist, in contrast to a politician, doesn't simply change allegiances. They simply try to make the best of a bad situation. They are the hapless victims of changing times and a dying industry. The machinery that really runs the world was working hard on solving another problem that had caused voters to vote in their own best interest, newspapers. The machinery had invent all sorts of new devices and systems to distract voters and keep them from voting in their own self interest or reading pesky newspapers. In spite of the machinery's efforts, journalists have become reasonably good at doing their job with the bad hand the machinery ensured they where dealt.

In this specific case and with this specific journalist, the best that could be made of the situation was printing the story that would make his career. It had been handed to him by a local hero who had disappeared without a trace or police lead. The journalist knew nothing of the hero. Just that a package that contained all the information he'd been trying to coax out of the machinery about a local crime boss and all the proof of the illegal activity.

The story the journalist produced with this information could not have been better written. The case against the local crime boss could not have been better presented. The story however was not the most important to the editor of the newspaper that day. The most important story was that of a beautiful and smart young girl who had died of an unknown condition right after hearing the news that her father was missing and presumed dead. The story of the crime boss was pushed further back into the newspaper where no one read it, except frail old women, heroes and villains.

After being released from minimum security prison the former CEO was hired as a consultant by a former crime boss who was in the process of turning his criminal operation into a legal enterprise specializing in the sale of a now legal and formerly common street drug. The former CEO helped the former crime boss turn the former criminal enterprise into a highly profitable and publicly traded company. A local stock broker made a prudent investment in the now legal company shortly after the company's initial public offering and made a sizeable fortune when he later sold the stock to other representatives of the machinery that really ran the world. The three men, all fine representatives of the machinery that really ran the world in their own right, met regularly at a local pub a few doors down from a successful local company, to discuss the now legal business of selling a formerly common street drug and to eat ham sandwiches. They really loved those ham sandwiches.

by Daniel Worth ( at March 18, 2015 04:45 PM

KXStudio News

Carla 2.0 beta4 is here!

Hello again everyone, we're glad to bring you the 4th beta of the upcoming Carla 2.0 release.
This release is mostly focused on bug-fixing, so there aren't many splashy new features to show compared to previous ones.
Still, here's the highlights:



Updated plugin skins

The plugin skins received some updates once again.
They can now be collapsed in order to take less space.
More to come soon.


New experimental plugins

Some of the best linux-standalone tools are now working as internal Carla plugins.
And because Carla exports its internal plugins as LV2, you'll also get them as LV2.
Note that this is still experimental!
Also, there's no support whatsoever from the original authors...


MOD GUI Support

Carla can now show LV2 MOD GUIs, handled like a regular LV2 UI type.
Note that this only works on the right setups (you need MOD-UI to be working first).
It's not available on pre-compiled binaries, but you can get it via the KXStudio repositories.

More changes

  • LinuxSampler code has been reworked and it's working better, it now exposes 2 output parameters.
  • The plugin bridge code has been reworked; bridges are much more stable and MIDI-out is working.
  • NSM code has also been reworked, testers welcome.
  • OSC ports can be static by using CARLA_OSC_TCP_PORT and CARLA_OSC_UDP_PORT environment variables.
  • Time panel can be shown/hidden as needed.
  • DISTRHO-based internal plugins are back, specifically 3BandEQ/Splitter, PingPongPan, Nekobi, MVerb, VectorJuice and WoobleJuice.
  • carla-single script is back, allowing you to quickly test and run all plugins.
  • Carla as plugin allows new, open and save-as (export) menu actions.
  • Start of new midi-sequencer plugin, still experimental and Linux-only for now.
  • MIDI file internal plugin now saves the contents, so you can share projects without worrying if the file exists on the other system.
  • Added 6 basic parameters to the ZynAddSubFX internal plugin.
  • New MIDI channel filter plugin.
  • LV2 and AU plugins are cached and automatically updated when needed, no need for scanning.
  • Patchbay mode is now working for non-JACK drivers.
  • Carla saves internal and external connections, specially useful in patchbay mode.
  • Lots and lots of bug fixes.

Special Notes

  • Renaming plugins currently is not safe (unless using Rack mode).
  • GIG/SF2/SFZ skin still to be done, and some others...
  • Plugin bridges only work on Linux right now. They used to be working for OSX but stopped due to a OS limitation.
  • Windows 64bit builds a shows small console windows when discovering plugins. This is not intended and will hopefully be fixed soon.


To download Carla binaries or source code, jump into the KXStudio downloads section.
If you're using the KXStudio repositories, you can simply install "carla-git" instead (plus "carla-lv2" and "carla-vst" if you're so inclined).
Bug reports and feature requests are welcome! Jump into the Carla's GitHub project page for those.

by falkTX at March 18, 2015 09:26 AM

March 16, 2015

Libre Music Production - Articles, Tutorials and News

JCM800 simulation plugin now available

Guitarix developer, Hermann Meyer has just announced a new LV2 plugin for the Guitarix LV2 plugin suite, Gxjcm800pre, a JCM800 simulation.

This simulation had previously been available within the Guitarix standalone program but is now also available as an LV2 plugin. The LV2 plugin includes tone, presence and master controls so that the full JCM800 is simulated.

by Conor at March 16, 2015 09:36 PM

DrumGizmo version released!

The DrumGizmo developers have just pushed out a hot fix release, version This fixes a rather serious bug in the resampling code that would cause sample skewing over the channels when resampling was enabled.

The latest version can be downloaded at

Don't forget you can visit the official DrumGizmo IRC channel at the Freenode network.

by Conor at March 16, 2015 09:07 PM


My first short story as an adult: An ode to Kurt Vonnegut

Requiem for a Hero Part I:

The satisfaction the hero felt in carrying out his personal brand of justice was scientifically comparable to the chemical reaction in the brain of an Olympic competitor winning a gold metal in their respective sport. He could, in many scientific circles, be described as an adrenaline junky. He was constantly chasing the natural rush of brain chemicals that came from delivering a quick and satisfying conclusion to the injustices of the world, no matter how minor.

He took great pride in himself and his impeccable morality. He did the right thing even if most people would think the ingression he was correcting was silly at best. One time he used his powers of deduction and reason to locate the owner of a $5 bill that he found windblown against a trash pile in an alley he happen to be in while surveilling an opportunity at getting those brain chemicals he so desperately needed. He had dreamed up a story while he searched for the owner of the cash. In his brain's narrative the person who lost the money was a little old lady on a fixed income who had out lived the rest of her family and the return of the cash would mean the difference between eating enough calories for her frail body to make another week and going hungry, risking escape into the dark abyss of non-existence. The hero imagined the old lady had been given the bill as change while filling a prescription at the local drug store and being too week to place it back into her billfold had opted to try and hold it feebly while still operating her walker and making her way slowly to the bus stop. He could see it clearly in his heroic minds eye that a burst of wind had torn the bill out of the old lady's age weakened hand and it landed neatly on the trash pile in the alley where he had found it.

The reality, as the hero soon found out, was that the owner of the bill was a stock broker who had given the bill to a homeless man holding a cardboard sign with a long and sad story about the various hardships that had befallen him written in black permanent marker. The stock broker hadn't read the sign, he'd simply dropped the bill on the top of the slouching man who had passed out from too much of his drug of choice, a common street drug sold to him by the low level employees of a local crime boss. The stock broker had given the money to the homeless man as a way of feeling slightly better about the large income he drew out of manipulating the worlds economy. He felt instantly better about himself and his place in the world and decided to treat himself to a beer and maybe a ham sandwich at a local pub as a reward for being so selfless. The stock broker had in fact played a small roll in the hardships listed on the homeless man's sign.

The homeless man had a minor mental disorder that was easily treated with prescription medication, but owing to a downsizing at his previous employer, he had been laid off, lost his health benefits and could not afford the medication his malfunctioning brain required. This event sent him into a spiral of self medicating with an addiction to a common street drug that worsened his brain's condition beyond the reach of modern medicine and led to his eventual homelessness. The cheap street drug released, temporarily, some chemicals in the homeless man's brain that made him forget that other brain chemicals where out of balance.The broker knew none of this because, as mentioned, he didn't read the sign the homeless man had propped against his unconscious body.

The downsizing at the homeless man's company had been triggered when the stock broker, seizing an opportunity at a large payday, had sold a very large portion of stock in the company based on a rumor he had heard from a colleague while peeing in an trough urinal at a baseball game. The colleague had told him that the companies earnings would be below market expectations. The large sell off of stock by the broker caused the machinery that actually operated the markets to view this trade as a trigger to sell more stock in the company and several other companies that did similar business. The drastic and sudden drop in the company's stock price triggered a panic in their upper management. The management thought they where doing a great job and in fact where in the process of preparing the annual earnings report that would inform the world that they had done such a great job at managing the company that it would, in spite of rumors to the contrary, be meeting market expectations. That didn't seem to matter to the stock market, and the CEO of the company in a very prudent and decisive move issued an order to downsize the corporate offices to ensure to the stock holders that management was making good use of their money and not wasting it on corporate excesses. None of the upper management where laid off, of course, and the company's stock quickly rebounded with the news of reduction in corporate overhead and solid earnings. They didn't rehire any of the employees that where laid off. They simply found a way to be just as profitable without them.

The bill the stock broker had dropped on the homeless man had simply blown away in one of the cities many and sporadic gusts caused by it's impossibly tall buildings. Neither of the last two owners of the bill had missed it's absence at all but the hero delivered it just the same, after all, it was the right thing to do.

The hero's next brain chemical fix, he hoped, would come from a taking down a local high level crime boss. This was the biggest and riskiest operation he'd ever taken on. It had taken him two years to gather the evidence and plan the villains take down. He could have finished the job six months earlier, but because of his impeccable morality he wanted to make absolute sure that the crime boss would end up, without a doubt, convicted by a jury of the his peers. His evidence was, at this moment, rock solid. There where indisputable pictures, audio recordings and video that was beyond the police's resources to acquire, but our hero, in his relentless determination and need for brain chemicals, had taken the time to prudently and legally amass an iron clad case the police would have in hand upon his single handed apprehension of the villain. He could see the accolades in his head now, the news stories, the adulation, maybe even a parade, and, of course, the sweet flood of endorphins and adrenaline he so desperately required.

The crime boss was an old hat at organized crime. He was handed the business by his father who had built it up from a local street gang in the decades previous. The crime boss had grown up in the crime business and was taught well by his successful criminal father in the day to day workings of such a complex and diversified crime organization. Much like the CEO of the homeless man's former employer, he didn't spend much time dwelling in the mundane day to day dealings of the criminals he employed. His job was to look at trends in the markets of the various criminal enterprises the crime family was involved in. He was very good at his job. There was no one better at crime than him. He would spend endless hours reading newspapers, looking for opportunities for his business in the headlines. He knew people at every company in town, including the homeless man's former employer, that gave him keen insight into how the city actually functioned. He knew every shipping container that could be exploited. How much inventory he could take off of it without making too many problems for himself. The exact amount of drugs and stolen goods he could place on the same ship as it headed towards it's outbound destination.

The crime boss had enough of the politicians and police force on his payroll to make his dealings all but invisible to the outside world. He even knew, in contrast to the CEO of the homeless man's former employer, how to deal with the unfortunate side effects of his criminal business. There was not a man in the city who's lifeless body could not be disposed of with shocking efficiency by employees of the crime boss. The CEO of the homeless man's former employer did not know how to deal with the unfortunate side effects of his business, the massive amounts of industrial waste that his company produced, so he simply ordered it dumped into the local waterways of the city. The crime boss not only knew of the CEO, he had extorted money from him to keep his secrets. The hero knew of the crime bosses connection with politics and law enforcement. He did not know of the CEO's existence or his illegal dumping of hazardous waste into the waterways thanks to the hush money paid to the crime boss by the CEO.

The CEO was completely unaware that he would soon be brought down by the EPA for these violations. The crime boss knew of the EPA's case against the CEO because he informed the police himself in order to keep pressure off his own criminal business. The crime boss was mostly unaware of the hero's plans to bring him to justice. He had heard some rumblings from his underlings of someone snooping around so he had hidden a gun in a pop up compartment in his desk as a precaution. The crime boss did not know about the hero. The hero did not know about the gun.

The hero had rehearsed the speech he would triumphantly deliver to the crime boss upon his apprehension. He knew every word and the exact emphasis he would deliver on each syllable. It would be the culmination of all his life's purpose. He would finally be on the map as true hero of the people. He revelled in the anticipation of his moment in the sun. He craved the release of chemicals that this event would release into his brain.

The indisputable evidence that was the fruit of the hero's two years of near obsessive work was all ready in the police stations mailbox as well as the mailbox of a local investigative reporter who also was working on writing the story that would make his career. The story of a crime family that ran the city . The reporter just lacked the evidence, that was now sitting in his mailbox thanks to the hero, to pull everything together.

The hero made his way undetected through the building where the crime boss ran his enterprise. He knew every security measure in the building, except for the gun in the crime boss's desk. He burst through the door of the crime boss's office and, having trapped his quarry and entered so elegantly undetected, began his well rehearsed speech. "Your time as a cancer on the underbelly of this city...." his voice was stopped abruptly by a bullet that burst out of the back of the his skull. The hero's brain had been distracted by the anticipation of the chemicals it so desperately desired that it did not react at all to the crime boss triggering of the hidden compartments release mechanism with his foot, his surprising speed at grabbing and discharging the gun and the accuracy of the his shot. The organ that the hero had hoped would release the chemicals he so desperately desired into his brain where now spread across the back wall of the crime bosses office. The hero made his escape into the dark abyss of non-existence.

The crime boss called over an intercom to his secretary and asked for her to get the employees who dealt with this sort of thing to come up and do their job. The crime boss had an important meeting with the chief of police in two hours and felt it a minor inconvenience to have to explain the mess. He also asked her to order him a ham sandwich from the local pub that was two doors down from the office. The crime boss really loved those sandwiches.

by Daniel Worth ( at March 16, 2015 05:13 PM

March 15, 2015

Libre Music Production - Articles, Tutorials and News

March 2015 Newsletter - Markus Schmidt interview, Pure Data tutorial and more!

Our newsletter for March is now sent to our subscribers. If you have not yet subscribed, you can do so from our start page.

You can also read the latest issue online. In it you will find:

  • 'LMP Asks' interview with Markus Schmidt
  • Pure Data tutorial (Part II)
  • New tool request form
  • New software release announcements

and more!

by admin at March 15, 2015 08:36 PM

March 12, 2015

Create Digital Music » open-source

Hands On MeeBlip anode, with Robert Lippok (raster noton) [Video]


When we designed MeeBlip anode, we tried to do more with less: make every knob and switch meaningful and musical.

Composer/musician and artist Robert Lippok invited us into his studio as he tried out those controls. Robert is really thoughtful about his approach to sound and control in my experience working with him, and so it was nice to get his feedback on our instrument. (If you don’t know Robert’s music, he is a Berlin native, a long-time member of the label raster noton, and a former member of the band To Rococo Rot.)

One by one, he demonstrates how these sound controls work. (This is just the default Pulse Width mode; there are more colors to access in the hidden wavetable mode.)

Our direct flash sale is over, but you can get MeeBlip anode right away – and support your local dealers – via our dealer network. That includes a number of stores that have done fantastic things to build the synth community, from the USA to Germany and beyond. It’s still available at a low cost:
MeeBlip Dealers

For more on Robert:
Robert Lippok [raster-noton Artists]

The post Hands On MeeBlip anode, with Robert Lippok (raster noton) [Video] appeared first on Create Digital Music.

by Peter Kirn at March 12, 2015 10:22 PM

Libre Music Production - Articles, Tutorials and News

March 10, 2015

Libre Music Production - Articles, Tutorials and News

EQ10Q V2-Beta7 Released

A new beta of EQ10Q V2, a powerful and flexible parametric EQ, has been released. Beta7 has many new features and improvements, including an updated user interface and a FFT visualization tool.

Inside the beta download you will also find a noise gate (GT10Q), compressor (CS10Q) and a bass enhancement plugin called Bassup. There are detailed overviews of each of the included plugins on the projects website.

by Conor at March 10, 2015 06:41 PM

Fourth beta release of Vee One Suite 0.6.1

Rui Nuno Capela has announced a fourth beta of his Vee One Suite of plugins, which includes an old school polyphonic synthesizer (synthv1), a polyphonic sampler (samplv1) and a drum-kit sampler (drumkv1).

The changelog for this release is as follows -

by Conor at March 10, 2015 06:35 PM

March 09, 2015

Vee One Suite 0.6.1 - A fourth beta release


The Vee One Suite of this old-school software instruments, also self-indicted as the gang of three usual suspects thou being: synthv1, as one polyphonic synthesizer, samplv1, a polyphonic sampler and drumkv1, as one drum-kit sampler, now released into the world, yet still beta.

Not much of any audible changes I must say for this so called fourth beta release though it goes as follows:

  • Added application description as's AppData.
  • Introducing LV2 port-groups (as proposed by Amadeus Folego aka. badosu, thanks).
  • Improved envelope widget nodes click-and-drag precision.
  • Introducing a brand new user preference on eye-candy: cf. Help/Configure.../Options/Custom style theme (applies to the JACK stand-alone client only though).
  • Envelope and filter now rendered with anti-aliased lines.
  • Fixed a Qt5 FTBFS re. QHeaderView::set[Section]ResizeMode().

There's no surprise as it's all made available in dual form, as usual:

  • a pure stand-alone JACK client with JACK-session, NSM (Non Session management) and both JACK MIDI and ALSA MIDI input support;
  • a LV2 instrument plug-in.

The Vee One Suite are free and open-source Linux Audio software, distributed under the terms of the GNU General Public License (GPL) version 2 or later.

Yet again, business as usual :/

synthv1 - an old-school polyphonic synthesizer

synthv1 0.6.1 (fourth official beta) has been released!

synthv1 is an old-school all-digital 4-oscillator subtractive polyphonic synthesizer with stereo fx.


Flattr this

samplv1 - an old-school polyphonic sampler

samplv1 0.6.1 (fourth official beta) has been released!

samplv1 is an old-school polyphonic sampler synthesizer with stereo fx.


Flattr this

drumkv1 - an old-school drum-kit sampler

drumkv1 0.6.1 (fourth official beta) has been released!

drumkv1 is an old-school drum-kit sampler synthesizer with stereo fx.


Flattr this

Enjoy && keep the fun ;)

by rncbc at March 09, 2015 06:30 PM

Hackaday » digital audio hacks

Logic Noise: Sawing Away with Analog Waveforms

Today we’ll take a journey into less noisy noise, and leave behind the comfortable digital world that we’ve been living in. The payoff? Smoother sounds, because today we start our trip into analog.

If you remember back to our first session when I was explaining how the basic oscillator loads and unloads a capacitor, triggering the output high or low when it crosses two different thresholds. At the time, we pointed out that there was a triangle waveform being generated, but that you’d have a hard time amplifying it without buffering. Today we buffer, and get that triangle wave out to our amplifiers.


But as long as we’re amplifying, we might as well overdrive the amps and head off to the land of distortion. We’ll do just that and build up a triangle-wave oscillator that can morph into a square wave, passing through a rounded-over kinda square wave along the way. The triangle sounds nice and mellow, and the square wave sounds bright and noisy. (You should be used to them by now…) And we get everything in between.

And while we’re at it, we might as well turn the triangle wave into a sawtooth for that nice buzzy-bass sound. Then we can turn the fat sawtooth into a much brighter sounding pulse wave, a near cousin of the square wave above.

What’s making all this work for us? Some dead-boring amplification with negative feedback, and the (mis-)use of a logic chip to get it. After the break I’ll introduce our Chip of the Day: the 4069UB.

If you somehow missed them, here are the first three installments of Logic Noise:

The 4069UB

4069ub_pinoutThe 4069UB is a hex (unbuffered) inverter. In fact, if you can remember the pinout of the 40106, this should look very familiar to you. The only difference is the lack of hysteresis (and the little squiggly symbols) in the inverters. But what a difference that makes! The lack of buffering and hysteresis in the inverter lets us use the individual amplifiers for analog purposes rather than digital / logic.

Remember that the “UB” part is mandatory for all of this to work. It stands for unbuffered, and that essentially means that there’s no special attempt made to convert the output into something digital inside the chip. (Some end in “UBE” or “UBF” or whatever. As long as there’s a “UB” somewhere, you’re set.) And it turns out that an unbuffered inverter is nothing more than a push-pull CMOS amplifier pair. Each “inverter” cell looks like this:


Ignoring the input-protection diodes, you can see that it’s basically just two transistors: an N-channel FET connected between output and ground and a P-channel FET connected between output and the power rail. (That’s the Complementary MOS pair that gives CMOS chips their name.)

If you’re not brushed up on your MOSFETs, the N-channel conducts when the input gate is pulled to a high voltage, and the P-channel conducts when the input gate is pulled low. This means that when the input voltage is low, the bottom FET doesn’t conduct and the top FET does, pulling the output voltage high. And vice-versa for a high input voltage. This makes a rudimentary logic inverter. Hooray!

But what happens in-between? At mid-supply voltages, both of the transistors will be turned on to varying degrees. This makes an output voltage that’s continuous, analog, and the “opposite” of the input. In order to give the chip a decent logic output, it needs to have a high gain through this middle zone so that voltages that are just a bit higher than the midpoint result in outputs that are clearly a logic zero.


The beauty of this chip for our purposes is the soft clipping effect that you get from the S-shaped gain curve above. That is, the gain rolls off (the line is less steep) near VCC and GND. This makes for a pleasing overdrive sound as we crank the amplifier up, and lets us control the amount of fuzz on the output by controlling the input volume and gain.

Buffers and Feedback

As we said above, the naked 4096UB chip has a very high gain right around the midpoint voltage, which is what makes it useful as a logic chip. To make it useful for amplifiying analog audio, we’ll use (negative) feedback to calm this gain down a little bit. By controlling the ratio of input signal to feedback, we can vary the output from nearly completely silent to distorted out to the limits of the voltage supply.

For starters, let’s aim to get a voltage gain of -1. That is, the output signal is just as big as the input signal but opposite in sign around the mid-point. This is an “inverting unity gain buffer” if you’re an electrical engineer. And buffers will allow us to listen in to signals that our amplifier’s input circuitry would otherwise swamp out.

Remember when we said that there was a triangle wave on the input terminals of the 40106 inverter? Did you try to plug them up to your amplifier? If so, it probably didn’t work although you can see it clear as day on the oscilloscope. Even when I can get it to work, there’s still a pitch shift that depends on the volume knob settings on my amplifier. Strange stuff! Clearly, the amplifier’s input circuitry is coupling with the oscillator. Putting a buffer circuit in-between will let the oscillator oscillate and the amplifier amplify without interacting with each other. That’s what buffers do. Let’s build.


The unity-gain buffer circuit is as simple as connecting the input through a resistor and then connecting another resistor with that same value in feedback between the output and the input. For intuition on how this works, let’s dig briefly into negative feedback amplifiers.

The intuition for this circuit (and all negative feedback topologies) involves first realizing that where the input signal and negative feedback meet, there can’t be any net signal voltage above or below the chip’s neutral voltage. If there were positive net signal, the inverter output would go negative until the feedback brought the junction of the two back down to neutral. If the input is negative with respect to neutral, the output will go positive and pull it back up. When the feedback path is working as intended, it’ll hold the input at the neutral voltage level.

A quick word about this neutral voltage. If you’re familiar with op amps, the neutral voltage is whatever’s present on the positive terminal. In our case, the chip switches from high to low around the mid-rail voltage, half of VCC, so that’s our neutral point. You can demonstrate this by unplugging the input and measuring what voltage level the output (and input) settle at with no signal present. It’ll be around VCC/2.

triangle_bufferedSo the first basic premise is that the feedback exactly cancels out the net signal where they meet up at the input of the inverter. This cancellation means that whatever signal current comes in through the input resistor has to get pulled on out through the feedback resistor. If you think of voltage as the force required to push a given current through a resistor, the output only has to work as hard as the input when the two resistors are equal. That is, when the input voltage is 0.1 volts above neutral, the output will be 0.1 volts below neutral because both are “fighting” the same resistance.

And there you have it: an “amplifier” with a gain of negative one. It doesn’t make the signal louder, but now you can plug the output of the buffer stage directly into your audio output and give it a listen without interference. And just for fun, this picture shows the input and output on the scope. Working as intended.

Amplifiers and Overdrive

Great. Now we’ve got a nice clean triangle wave oscillator. You’d think we were done here, but we still have five inverter gates sitting unused on the 4069UB. What could we do with five more amplifiers? Five more amplifiers that have a nice smooth rolloff much like old-school tube preamps do? Crank it up to 11 and see how it sounds!

To go from buffer circuit to amplifier circuit, we can either let the input signal flow in more easily (reduce the input resistance) or force the output to work harder (increase the feedback resistance). Either way, the goal is to increase the ratio of feedback resistor to input resistor, and thus the voltage gain.

So let’s build up another buffer circuit, but instead of a 100k Ohm resistor on the input, let’s use a 100k potentiometer so that we can let more signal in. Now it’s an amplifier, with the gain controlled by the ratio of the feedback resistor (at 100k Ohms) divided by whatever resistance we dial in on the input potentiometer. (You could use a larger pot than feedback resistor, and you’d be able to make the circuit quieter as well. But that’s boring.)

As you drop the input resistance down to zero, you’d naively expect the amplification gain to head off to infinity. Instead, we see that the gain reduces gradually as the output voltage approaches the GND or VCC power rails. What happens is that real-world effects like the chip’s amplification rolloff take over. Is this a bad thing? Not if you want a nice soft-clipping amplifier overdrive sound added to our triangle wave. Woot.


Now as long as we have a bunch of free inverters sitting around, let’s take the output from the overdrive sound and re-amplify it again. The IC’s built-in soft clipping will limit the volume gain, but we’ll get something that’s ever more like a square wave as we keep passing the signal through further amplification stages. Note that the fuzz stage runs at full gain — without negative feedback. We’re going for fuzz distortion here. For my liking, a single extra amp stage suffices to get a nice fuzz tone, but you could chain up as many stages with and without feedback as you want. Heck, half of the chip is still sitting there unused, go nuts.


Here are some example waveforms from the first-stage amplifier and the second. At the low-gain end of things, you can see that the first-stage triangle wave, in yellow, is not very distorted yet. But as we turn up the gain, the points get rounded over on top and it approaches a round square wave. (“Round square”?) The second-stage output, in green, starts off pretty much squared-out and gets more so. Between the two outputs, you have mild overdrive and full fuzz. Can’t complain about that.

The scope traces below show the overdrive output in yellow and the fuzz output in green with the volume knob turned increasingly up. You can see that the as you increase the gain, the fuzz channel takes off essentially where the overdrive channel leaves off.


And don’t hesitate to feed other audio sources into this chip. A version of this circuit dates back to the late 1970’s, known as [Craig Anderton’s] “Tube Sound Fuzz” from his book Electronic Projects for Musicians. My wasted youth doesn’t look so wasted anymore, huh?

Sawtooth Waves

OK, so we’ve got a nice variable overdrive version of the triangle wave oscillator. What else can we do with our newfound analog powers? Here, the most bang for our breadboard buck is to add a diode into the feedback path of the oscillator, turning the triangle wave into a sawtooth.


How does that work? Well, instead of charging and discharging the timing capacitor through the feedback resistor as we’ve been doing, we charge it much faster through the diode. This makes the input voltage jump up, setting the output low almost instantly. The diode only conducts in the charging direction, so the capacitor has to discharge slowly through the feedback resistor. This goes on until it hits the threshold value where the output goes high again and charges up the capacitor very quickly through the diode again. In short, we’ll end up with a voltage waveform on the input here in yellow, and on the output here in green:


Now all that’s left to do is pass this sawtooth through the buffer amplifier above. That’s that raspy, bowed-string sound that a sawtooth wave makes. Played down low, you get the classic acid-house bassline. Go nuts. But wait, there’s more. We have a sawtooth plus overdrive, plus full-on fuzz.

Below is the scope trace from medium and full gain for the overdrive output in yellow and the fuzz output in green. With the sawtooth wave, the fuzz ends up converting the sawtooth into a kind of pulse wave. It’s not symmetrically square both because our sawtooth isn’t perfectly straight and because there’s some DC offset voltage propagating through the three stages that we haven’t been careful with. If you want to remove that, you can insert something like 0.1uF blocking capacitors between the stages, but I feel you lose some of the gritty character of this thing by doing so.


Next Installment: Filters and Drums

Now that we have some classic analog synth waveforms under our belts, it’s time to add some filter effects and drums. To do so, we’ll continue down the analog path that we started this time, so if you don’t already have a couple of 4069UBs at hand, you have another week to scrounge some up.

Filed under: digital audio hacks, Featured

by Elliot Williams at March 09, 2015 05:01 PM

March 08, 2015


BEAM Technology Photopopper

picked this popper up again. It needed some solder iron care and sun, lots of sun.
a prequel to the ordered Arduino and soon to be announced project.

by pete0verse at March 08, 2015 11:14 PM

Install Bind9 In A Chroot Jail

after completing these simple steps you should have a DNS Cache server running. enjoy

	apt-get install bind9 bind9-doc dnsutils

It will probably autostart after install, so stop it before proceeding:

	/etc/init.d/bind9 stop
  1. Create your chroot. This requires a minimal file tree:
    	mkdir -p /var/chroot/bind9/{etc,dev,var/cache/bind,var/run/bind/run}
  2. And some devices:
  3. # mknod /var/chroot/bind9/dev/null c 1 3
    	mknod /var/chroot/bind9/dev/random c 1 8
    	chmod 666 /var/chroot/bind9/dev/{null,random}
  4. Move your default configuration files:
    	mv /etc/bind /var/chroot/bind9/etc
    	ln -s /var/chroot/bind9/etc/bind /etc/bind
  5. Tell rsyslog to listen for log events in the chroot:
    	vi /etc/rsyslog.d/bind-chroot.conf

    and add the line:

  6. Tell bind9 init to use the chroot:
    	vi /etc/default/bind9

    and add:

    	bind -t /var/chroot/bind9"
  7. Restart syslogd and make sure it creates /dev/log in the chroot.
    	/etc/init.d/rsyslog restart
    	system log daemon: syslogd.


    	ls -al /var/chroot/bind9/dev/log
    	1 root root 0 2008-10-09 14:48 /var/chroot/bind9/dev/log
  8. Start bind9 and make sure it works
    	/etc/init.d/bind9 start
    	domain name service...: bind.
    	ps ax | grep [n]amed
    	?        Ssl    0:00 /usr/sbin/named -u bind -t /var/chroot/bind9
    	host localhost.

Now, you’re done the chroot portion. Copy over your old named.conf.local and

by pete0verse at March 08, 2015 10:54 PM

March 06, 2015

Create Digital Music » open-source

Watch a Dreamy, Groovy Reverie Played Live on Desktop Synths

Jeremy Blake (aka Jeremy Leaird-Koch) is the kind of omni-dimensional talent who that seems tailored for the age of Web media. Yes, he’s an electronic musician, but … have a listen to his SoundCloud, and you’ll find the common thread is craft more than genre. And yes, he’s also a video editor, who’s also making imaginative and dazzling visuals.

Let’s instead just wander into his studio, virtually speaking, and let him play for us on a nice, assembled gathering of custom hardware.

And drifting off on this chillout groove is a nice way to take a pause in your day…

Ableton – Clock and recording | [Sonic Potions] LXR drum machine (clock from Ableton – clock to Zaquencer) | Behringer BCR200 – running Zaquencer | 2x MeeBlip [SE] and Access Virus A (Zaquencer) | [Teenage Engineering] OP-1 (clock from Ableton tape loops and live playing)

It’s all a nice rig, desktop units pouring over with personality. We’ve talked before about how nice the Zaquencer sequencer on the BCR is. The OP-1 pads sound gorgeous. And it’s really nice seeing the LXR drum machine as a centerpiece (instead of something more obvious like an Elektron, perhaps). It’s a remaining open hardware kit design even as others have disappeared, and while it’s not the easiest build, it’s a really cool bit of kit.

One of the bits of hardware is, of course, co-created by CDM. MeeBlip designer/engineer James and I been revisiting our own MeeBlip SE lately; he’s got not one, but two of them here. And there are things we like about it, even if we prefer the sound, controls, and filter on the newer model. I love the way it sounds here, though, which could certainly be applied to the Child of MeeBlip, MeeBlip anode.

More from Jeremy’s music feed:

And I love this “Vanitas” release:

Vanitas by Jeremy Blake

On the visual side, here’s his showreel – see, this kind of Renaissance-do-everything approach is what I love about the California scene at its best (Jeremy is Oakland-based):

[S+V] – sound+vision 2014 Showreel from Jeremy Leaird-Koch on Vimeo.


The post Watch a Dreamy, Groovy Reverie Played Live on Desktop Synths appeared first on Create Digital Music.

by Peter Kirn at March 06, 2015 01:13 PM

March 04, 2015

QXGEdit 0.2.0 is out!

Every couple of years I decide to do some spring cleaning, a bit early this time, perhaps...

And then again I stepped into this kind of pure nineties junkyard synth that's still powering on here and then with great joy. And that's happening on every PCI sound-card slot that can be found around here. All about that Yamaha DB50XG (nb. fact is Yamaha doesn't list it on the product archives anymore, so this might be all just archaeology by now...)

Nevertheless, here it goes again:

QXGEdit 0.2.0 is out!

QXGEdit is a live XG instrument editor, specialized on editing MIDI System Exclusive files (.syx) for the Yamaha DB50XG and thus probably a baseline for many other XG devices.

Flattr this


Project page:



  • In a glance, all GUI toolbox pages converted into tabs.
  • Introducing a brand new user preference on eye-candy: cf. View/Options.../Display/Widget style theme.
  • Most graphics now rendered with anti-aliased lines.
  • A man page has beed added.
  • Allow the build system to include an user specified LDFLAGS.
  • Fix port origin on MIDI RPN/NRPN 14-bit controllers input.

Weblog (upstream support):


QXGEdit is free, open-source software, distributed under the terms of the GNU General Public License (GPL) version 2 or later.


Yamaha DB50XG Owner's Manual

by rncbc at March 04, 2015 06:30 PM


It's got a big mouth, just like me.

I am at least self aware enough to understand that a water bottle is a pretty strange thing to write a blog post about, but I'm nothing if not a man with strong feelings, sometimes about inane things like water bottles.

For years I was in love with Nalgene brand wide mouth, and even narrow mouth water bottles but then the BPA débâcle happened and I gave them up. I switched, much to my dismay, to stainless steel but I missed my Nalgene bottles more than is healthy for an adult male.

When they came out with the BPA free versions I switched back and I have to say, it's one of my favourite accessories. For those of you that know me, you also know that I'm very rarely without my Nalgene in tow.

So why do I love my Nalgene so much?

 First, they are cheap and available pretty much anywhere for under $10 and it comes in many different colors. I very rarely lose my water bottle, but when I do I can replace it with a visit to just about any store anywhere.

It's virtually indestructible. I've dropped them thousands of times and they hold up to my years of abuse.

The wide mouth means I can load it up with ice easily and I like a lot of ice in my water.

Accessories, there are a surprising amount of accessories available for them, my two favourites are the GSI Outdoors H2OH! Percolator and the Outdoor Research Bottle Parka.

It's made of Lexan and that means it can handle temperatures up to the boiling point of water. I first heard about this on the website where people where talking about using them as hot water bottles on chilly nights to squeeze a few more degrees of comfort out of their sleeping systems, since then I've used them quite regularly as a hot water bottle to help sooth my chronic shoulder pain. I even sewed my own cover filled with rice to insulate myself from the high temps and make the heat last longer. It's really amazing at putting the right amount of heat right where I need it. I also have a crazy story, that I won't share right, now about saving a couple friends life on the side of a mountain by making hot water bottles in cold temps.

I really do view my Nalgene bottle as one of the few things I really can't do without.

by Daniel Worth ( at March 04, 2015 06:05 PM

Hackaday » digital audio hacks

Hard Drive… Speakers?

Speakers really aren’t that complex to make. In fact, if you’re clever about it, you can make a speaker out of just about anything. [Afroman] is kicking it old school with a hack he first did back in 2001, but now, in video form: Make your own HDD Speaker!

All you need is an old hard drive you don’t care about anymore, a bit of flexible wire, and an externally powered amplifier (no your cellphone will not work!). If you don’t have an amp, [Afroman] even has a tutorial so you can build your own Class D Amplifier on a breadboard!

First off you’ll need to crack open the HDD enclosure. You might need a torx or hex key to get past the manufacturer’s “safety screws” though. Once it’s open you’ll need to locate the hard drive head — this is the small metal arm that looks kind of like a record player tone arm. It’s actually controlled by a coil, you know, just like a speaker…

Get out your multimeter and start probing! The ribbon cable coming from the hard drive head will have two wires that have a resistance anywhere from 4 to 40 ohms — this is actually the coil that controls the head, hence the resistance. Solder your wires in there and give it an amplified audio signal, and that’s it!

For a slightly more functional speaker, why not make one out of glass? Or maybe fabric?

Filed under: digital audio hacks

by James Hobson at March 04, 2015 03:00 AM

March 03, 2015

Libre Music Production - Articles, Tutorials and News

LMP Asks #6: An interview with Markus Schmidt

This month we talked to Markus Schmidt. Markus has been a member of the Calf team since 2009. As well as being the brains behind many of the Calf plugins, Markus is also responsible for the design of every visual aspect of Calf.

Hi Markus, thank you for taking the time to do this interview. Where do you live, and what do you do for a living?

by Conor at March 03, 2015 08:17 AM

March 02, 2015

PipeManMusic and New Blog

Just realizing that there are some of you that follow this blog that don't necessarily follow me in other places. So I thought I'd post a quick update to say, any farm related stuff has been moved off this blog and onto and if you want to check out the new website I'd love to hear some feedback on it.

by Daniel Worth ( at March 02, 2015 06:13 PM

Hackaday » digital audio hacks

An Upgrade To A Raspberry Pi Media Server

For the last few years, [Luke] has been running a music server with a Raspberry Pi. With the new Raspberry Pi 2 and its quad core processor, he thought it was time for an upgrade.

The build consists of a Raspi 2, a HiFiBerry Dac to address the complaints of terrible audio on the Pi, an aluminum enclosure, and some electronics for IO and a real software shutdown for the Pi. The Arduino also handles an IR remote and a rotary encoder on the front of the enclosure.

The software is the Logitech Media Server along with Squeezeslave. The front end is custom, though, with functions for shutdown and receiving IR remote codes. Everything is served up by Flask, with a 32GB microSD card stuffed into the Pi to store MP3s. All in all, a great build.

Filed under: digital audio hacks, Raspberry Pi

by Brian Benchoff at March 02, 2015 03:00 AM

February 28, 2015

Libre Music Production - Articles, Tutorials and News

Date set for MuseScore 2.0 release candidate

Fans of MuseScore will be happy to know that version 2.0 is getting closer. A date for the release candidate has now been set for March.

Full details about the release schedule can be found at the MuseScore forum.

You'll also find a useful rundown of the features in the up and coming 2.0 release on this blog post.

by Conor at February 28, 2015 07:08 PM

Hackaday » digital audio hacks

DSP 01: Real, Legit Audiophile Goodness

About six months ago, we saw [tshen2]’s work on the DSP 01, a 2-input, 6-output DSP and crossover for extreme audiophiles, and we’re not talking about oxygen free rooms here. The DSP 01 turns a USB audio output into six outputs that will give you perfectly flat eq across bass, mids, and highs, integrates with a 6x100W amplifier, and compensates for room noise. There was a huge update to the project recently and [tshen] is more than happy to share the details

Getting to this phase of the project hasn’t been without its problems. To get the DSP communicating to a computer through a USB port, [tshen2] found a potential solution in the CP2114 USB to I2S Bridge. This device should function as a USB audio sink, translating digital audio into something the DSP understands. This chip did not work in [tshen]’s design. The CP2114 simply does I2S wrong; the I2S spec says the clock must be continuous. This chip implements I2S with a SPI, firmware, and a few other things, making it incompatible with to-spec I2S.

While there was some problems with getting audio in to the device, the core of the device has remained unchanged. [tshen2] is still using the Analog Devices DSP, with the interesting SigmaStudio being used to compensate for the frequency response of the room. This real, legit, science-based audiophile territory here, and an impressive development for a field that – sometimes understandably – doesn’t get the respect it deserves.

Filed under: digital audio hacks

by Brian Benchoff at February 28, 2015 06:00 AM

February 26, 2015


Jury Duty

Here is an account of my recent trip to the county court house to fulfill my civic duty right up until I was selected and served on a jury. Enjoy!

First observation, great place to people watch. 

Only one of the the security lines running, very long line, I doubt other two x-ray machines are even plugged in, they are just there to torment me with the possibility. While in line I discover wood chips in my hoody pocket, hope I don't have to explain that in a pat down.

Only place on earth there are people grumpier than me. Lady on phone behind me would rather clean a dirty toilet than be here or so she says loudly to the person on the other end of the conversation. I'd rather not do either or here about it from her.
They miss pronounced my last name over intercom. It's a common English word, go judicial/educational system. 

We are all Given a name tag that just says "Juror", everyone obediently wearing them like sheep, I judge them. I'm just wearing mine to be ironic so it looks cool on me. I still don't really know what ironic means. That song really fucked me up. 

The sign on fancy automatic coffee maker, just above dispensing nozzle says, not a drain. Must be an interesting story there. Size options on machine are as follows, coffee bean, cup, coffee bean, I chose cup, but secretly wished I tried coffee bean. Later, tried coffee bean option, said "invalid option" on LCD screen, at least the machine is aware of the paradox even if it's incapable of changing it. Chairs designed to not let a cup sit flat, no where to set cup, another well thought out form of torture.

Selected in the first round to move on, I finally found what I'm lucky at. Yay.

Questionnaire asked my favorite t.v. show, author and type of music. I think the people who wrote the form got tired of where people work. They are people watchers too. I think I miss spelled Vonnegut, attempt to seem smart backfired on me again, go educational system.
More newspapers than tablets, more hardback books than tablets. Like they are all from a different universe. Old people still not using smart phones when bored, I don't know how to solve this problem but I imagine it involves hard candy in some way. 

Saw guy that looks like Kurt Vonnegut, not the best celebrity to look like. I didn't tell him he looked like him, I'm sure he gets told that a lot. 

They let us have a fifteen minute break, only options are smoking and eating junk food at a bad cafeteria, go society. I chose writing this on my tablet and looking smug. 

Got called to a court room in first round, go universe that is constantly against me.
Took stairs to fourth floor court room instead of elevator to feel superior to everyone else, instead I'm just breathing heavily like a creeper. More cardio could be in order. 

Everyone is sitting on one side of benches, when I ask "Is the other side is off limits?" everyone smiles politely and shrugs, they are sheep, I sit on the other side and everyone after me follows my lead, I'm a trailblazer. 

Felony vehicular eluding, sounds fun.

Just found out, Jehovah's witness don't serve on jury's, a tiny upside to religion. 

I can't seem to win at anything in life ever, except getting selected to be a juror. I don't know what message the universe is trying to send me but I suspect it's just drunk dialing

by Daniel Worth ( at February 26, 2015 01:09 PM

Libre Music Production - Articles, Tutorials and News

ZynAddSubFX 2.5.0 is now available

The 2.5.0 Release of ZynAddSubFX is now available.

This release is mainly focused on fixing some of the core architectural flaws that have historically existed. As a result this release should behave much better under jack and interfacing with the realtime side of things is much easier now.

For full details, check out fundamental's post over at linuxmusicians.

by Conor at February 26, 2015 09:47 AM

Guitarix: First Steps Towards New Design

Due to a recent call from the Guitarix devs for a graphic designer, Markus Schmidt from Calf Studio Gear has got in touch with them and taken on the task. For those who don't know who Markus is, he has not only created a lot of the Calf plugins but is also the guy responsible for their graphical interfaces.

by Conor at February 26, 2015 08:15 AM

February 25, 2015

Linux Audio Users & Musicians Video Blog

ams-lv2 modular synth plugin

Aurélien Leblond has been working hard to port Alsa Modular Synth to an LV2 plugin. The results speak for themselves.

He has also released the Deteriorate plugin which you can see a demo of here too.

by DJ Kotau at February 25, 2015 07:34 AM

February 24, 2015

Hackaday » digital audio hacks

We Assume Control: SPI and a Digital Potentiometer

In the last video I demonstrated a Universal Active Filter that I could adjust with a dual-gang potentiometer, here I replace the potentiometer with a processor controlled solid-state potentiometer. For those that are too young to remember, we used to say “solid-state” to differentiate between that and something that used vacuum tubes… mostly we meant you could drop it without it breakage.

Using SPI to set Cutoff of Low Pass Filter

Using SPI to set Cutoff of Low Pass Filter

" data-medium-file="" data-large-file="" />
UAF42 Filter with Dual Ganged Pots

UAF42 Filter with Dual Ganged Pots

" data-medium-file="" data-large-file="" />

The most common way to control the everyday peripheral chips available is through use of one of the common Serial Protocols such as I2C and SPI.  In the before-time back when we had only 8 bits and were lucky if 7 of them worked, we used to have to memory map a peripheral or Input/Output (I/O) controller which means we had to take many control and data lines from the microprocessor such as Data, Address, Read/Write, system clocks and several other signals just to write to a couple of control registers buried in a chip.

Nowadays there is a proliferation of microcontrollers that tend to have built-in serial interface capability it is pretty straightforward to control a full range of peripheral functions; digital and analog alike.  Rather than map each peripheral using said data and address lines,which is a very parallel approach,  the controller communicates with peripherals serially using but a handful of signal lines such as serial data and clock. A major task of old system design, mapping of I/O and peripherals, is no longer needed.

Using Digital to Control Analog

Two serial interfaces have risen to the top of the heap as far as prevalence: I2C and SPI.  I2C is a more sophisticated protocol that arbitrates who should do the talking and is basically bidirectional meaning that the data input pin can double as a data output. I2C also implies peripheral IC’s that have pre-assigned addresses and since the receivers are addressable, all can be connected together on the same I2C bus.  I2C is all the better if you don’t have to debug it which I have had to do in the earlier days of the protocols existence, (but that was a while back).

SPI and I2C Protocol ComparisonSPI and I2C Protocol Comparison

I consider SPI, short for Serial Peripheral Interface, to be more of an attitude than a strict protocol as I have seen various specifications for how clocks and selects work so it is usually worth checking the details if designing for production. At the heart of SPI is a separate Chip Select for each device and a dedicated data input and output.  On the plus side the data lines don’t have to worry about being bidirectional or having to deal with contention, and so they are designed as true active high and active low driven lines whereas I2C has a passive pull-up which may limit maximum speeds or loads.

In this instance I chose the digital potentiometer that I wanted and let that determine the Serial Protocol. In the video you will see the various controllers and processors that I looked at and settled on the Hackaday Pro Trinket for the simple reason it has a Hackaday skull on it.

Hackaday Pro TrinketHackaday Pro Trinket

A quick download of the IDE and I was able to speak to the module via the bootloader.  Perusing the built-in examples gives us not only an SPI based project written in ”C” but also one of the two SPI examples is for a digital potentiometer.  I have elected to use the MCP4161 Digital Potentiometer and even though it is a different part than the SPI example, the changes needed to the code are minor.  Looking at the datasheet we find that writing a value of zero first and then a second value which indicates the resistance value of the potentiometer as a $00-$FF hexadecimal range of 256 steps.  The example code sits in a loop incrementing both bytes so I changed the first byte to $00 and left the incrementing code alone as being useful for our demonstration here and recompiled.

SPI Protocol Writing to Digital PotentiometerSPI Protocol Writing to Digital Potentiometer

My original plan was to demonstrate the digital pot and the filter it controlled on one PCB but ran into problems with the compatibility of too many power supplies, the grounds and even the voltage drop of the long USB cable I used to drive the demo from across the room.  Using a small solderless breadboard it was straightforward to hook up the digital pots to the SPI bus and then swap them in place of the dual ganged pot.


Active Filer, Digital Potentiometer and Hackaday Pro TrinketActive Filer, Digital Potentiometer and Hackaday Pro Trinket

If you didn’t see the previous video, I use a sweep frequency generator to demonstrate the effects of our adjustable filter.  The function generator starts by outputting a low frequency and then quickly sweeping up to a higher frequency.

This has the effect that a properly triggered oscilloscope displays low frequencies on the left side of the display and high frequencies to the right.  The frequency response of the filter as it moves between the low and high frequencies is seen as moving between the left and right sides of the display where the x direction indicates frequency.

Low Pass Filter Sweep - Left to Right

Low Pass Filter Sweep – Left to Right

" data-medium-file="" data-large-file="" />
Using SPI to set Cutoff of Low Pass Filter

Using SPI to set Cutoff of Low Pass Filter

" data-medium-file="" data-large-file="" />

Like our last demonstration the filters are seen moving up and down the range only now it is under the control of a simple C program and not a manual adjustment.  Picture if you will, then an analog synthesizer that instead of a carefully calibrated control voltage to manage oscillators, filters and other effects, all while tracking each other closely without worrying about linearity or temperature affecting the accuracy of the control.

An Analog View

Finally, to visually demonstrate that digitally controlled potentiometer really does emulate a variable resistor I hooked up my old Simpson 260 Volt Ohm Meter (VOM) that I have had since I was 16.  Let’s just say that means I have had it for almost 40 years. Setting the VOM to resistance and remembering that Zero ohms is a deflection to the right the effects of the incrementing potentiometer are readily seen.

Simpson 260 showing an SPI controlled Digital PotentiometerSimpson 260 showing an SPI controlled Digital Potentiometer

This was just a simple example of having a processor control our analog project.  These days I automatically assume that there will be a serial control bus or two in any sizable project.

Filed under: ATtiny Hacks, digital audio hacks, Featured, slider

by Bil Herd at February 24, 2015 03:00 PM

February 23, 2015

Hackaday » digital audio hacks

Making a Homemade Stephen Hawking

It isn’t easy communicating when you have any form of speech impairment. In such cases, a Speech-generating device (SGD) becomes essential to help you talk to the world. When coupled with other ailments that limit body movement, the problem becomes worse. How do you type on a keyboard when you can’t move your hands, and how do you talk when your voice box doesn’t work. Well known Scientist Stephen Hawking has been battling this since 1985. Back then, it took a lot of hardware to build a text entry interface and a text to speech device allowing him to communicate.

But [Marquis de Geek] did a quick hack using just a few parts to make a Voice Box that sounds like Stephen Hawking. Using an arcade push button to act as a single button keyboard, an Arduino, a 74HC595 shift register, a 2-line LCD, and the SP0256 hooked to an audio amplifier / speaker, he built the stand-alone speech synthesizer which sounds just like the voice box that  Stephen Hawking uses. Although Dr. Hawking’s speech hardware is quite complex, [Marquis de Geek]’s hack shows that it’s possible to have similar results using off the shelf parts for a low cost solution.

There aren’t a lot of those SP0256-AL2 chips around. We found just a couple of retailers with small stock levels, so if you want to make one of these voice boxes, better grab those chips while they last. The character entry is not quick, requiring several button presses to get to the character you want to select. But it makes things easier for someone who cannot move their hands or use all fingers. A lot of kids grew up using Speak and Spell, but the hardware inside that box wasn’t the easiest to hack into. For a demo of [Marquis de Geek]’s homemade Hawking voice box, check the video below.

Filed under: digital audio hacks

by Anool Mahidharia at February 23, 2015 06:00 PM