Linux DevCenter    
 Published on Linux DevCenter (http://www.linuxdevcenter.com/)
 See this if you're having trouble printing code examples


Rockin' in the Free Software World

by Dave Phillips
07/20/2001

I've been playing the guitar much longer than I've been playing with Linux, so it was only a matter of time before I'd take a closer look at the software available to the Linux guitarist. I was happily surprised by what I found, and I'll share some of my discoveries in the course of this article.

I've divided Linux software for guitarists into a few broad categories:

Let's take a look at some interesting software from each of those categories, starting with notation exchange media.

File exchange formats: Standard notation, ChordPro, and tablature

Standard notation

The general subject of music notation software is broader than space for this article permits. However, guitarists of all styles commonly encounter standard music notation in sheet music, songbooks, magazines, theory, and other textbooks, and even on the Web, so a few words on the subject are in order.

Linux can claim several general notation packages with a variety of intended uses. Some packages are designed for music typesetting (MusicTeX and its clan members) while others are more composer/arranger-friendly applications such as NoteEdit or Mup. As much as I'd like to provide full reviews of this software, I'm going to remain focused on guitar-specific software. Readers interested in the available Linux notation packages should investigate the links found on the music notation software page of the Linux soundapps site.

Comment on this articleOK, you guitar players out there ... what did Dave forget to talk about that other musicians would want to know?
Post your comments

The ChordPro and Chord file formats

The ChordPro file format is a lightweight and convenient means for guitarists to exchange song lyrics and chords over the Internet, typically via Usenet newsgroups or Web pages dedicated to ChordPro file collections. A ChordPro file is written in simple ASCII text that can be edited with any standard text editor, and is named with the chopro or pro extension. Here's a simple example downloaded from OLGA, the online guitar archive of songs in ChordPro, Chord, and tablature formats :

# From: kharding@lamar.ColoState.EDU (Karol Harding)
{t:SILENT NIGHT}

{c:key of A}
[A]Silent night, holy [A7]night
[E7/Bm]All is cal[E]m, [F#m/A]All is b[A7]right
[D]Round yon Vir - gin, [A]Mother and Child
[D]Holy Infant so [A]Tender and [A7]mild,
[Bm]Sleep in h[E7]eavenly [F#m]peace,
[A]Sleep in [D]heavenly [A]peace.

Silent night, holy night
Shepherds quake at the sight,
Glories stream from heaven afar,
Heavenly hosts sing Alleleu- lia
Christ the Savior is born!
Christ the savior is born.

The curly braces hold directives that include information about the song, including title, artist, key, and chord definitions. Brackets contain the name of the chord to be played when the following word or syllable is sung. The hash symbol (#) precedes comments.

ChordPro is well represented in Internet song collections such as The ChordPro Guitar Archive and OLGA.

Chord is an older Unix program that converts simple ASCII text files to PostScript files. Its crd format is also popular on OLGA and is frequently encountered on the Usenet newsgroups devoted to tablature. The formal layout of a crd file is somewhat looser than ChordPro, as the following example illustrates:

SILENT NIGHT
Joseph Mohr, Franz Gruber. publ.1818
[suggest capo III]

Silent night! Holy night! [G]
All is calm, all is bright [D7 G]
Round yon Virgin Mother and Child [C G]
Holy Infant so tender and mild [C G]
Sleep in heavenly peace, [D7 Em Em/C#]
sleep in heavenly peace. [G D7 G]

Unlike the ChordPro format, a crd file supposes that the guitarist knows where the chords should be placed within the melody.

Now that we understand the chopro and crd formats, let's look at some Linux software that works with them.

Chordpack

Daniel Polansky's Chordpack is a Perl script that converts a ChordPro input file into a TeX, HTML, or ASCII file. It is also capable of converting ASCII text files to "near-ChordPro" files.

Chordpack is a console application, so we'll take a look at some typical command sequences. These commands take in a file in ChordPro format and create the indicated output file:

[chordpack]$ ./chordpack html SilentNight.chopro > SilentNight.html

[chordpack]$ ./chordpack tex SilentNight.chopro > SilentNight.tex

[chordpack]$ ./chordpack ascii SilentNight.chopro > SilentNight.txt

Users not familiar with the TeX typesetting package may not know how to view a tex file. Assuming a working TeX installation, the viewing procedure is simple: First, convert your tex file to dvi format:

latex SilentNight.tex

This command will automatically create an output file named SilentNight.dvi. You can now view that file in X with the xdvi utility:

xdvi SilentNight.dvi

Other command switches are available for transposing the song during transcription, setting font sizes, and using a song list file. As seen in the illustrations, Chordpack's output is clear and well-formatted (see Figures 1, 2, and 3), and its documentation tells you everything else need to know about the program.

Screen shot.
Figure 1. Chordpack HTML Output.

Screen shot.
Figure 2. Chordpack LaTeX Output.

Screen shot.
Figure 3. Chordpack ASCII Output.

GuitarTeX

Joachim Miltz's GuitarTeX also produces song sheets from files in the Chord or ChordPro formats. The program presents the user with a Perl/Tk graphical interface complete with pull-down menus filled with the various options and parameters for creating the output file -- including options for creating formatted and indexed songbooks. GuitarTeX converts an original ChordPro file to a TeX, PostScript, or Adobe PDF file, and it will also convert a crd file to the ChordPro chopro format. We've already seen some TeX output from Chordpack, so let's take a look at GuitarTeX's PostScript and PDF output.

The GUI is simple to navigate and the program is very easy to use. Open your ChordPro file from File/Open. The display area will fill with the ChordPro format text (Figure 4). Go to File/Export and select PostScript from the submenu: In a few moments, you will have a new file in the PostScript .ps format. Repeat this procedure for creating a PDF file, and that's all there is to converting ChordPro files to PostScript and PDF files.

Screen shot.
Figure 4. GuitarTeX Imports A ChordPro File.

Like Chordpack, GuitarTeX can automatically transpose your song's chords. In Figure 5, we see our example file shifted up to the key of C: The transposition was made by pressing the upward-pointing arrow three times, raising the key-center three half-steps. Thus we moved from the original key of A up to a new key of C. Note that the original directive line {c:key of A} had to be manually edited to accurately reflect the change.

Screen shot.
Figure 5. GuitarTeX Transposition.

You can explore GuitarTeX's other features at your leisure. At this point I must move on to that other ubiquitous notation so familiar to guitarists....

Tablature

Tablature (also just called "tab") is a notation system based on a physical representation of the instrument. Standard guitar tablature uses six horizontal lines to indicate the individual strings of the instrument, while vertical lines demarcate the measure boundaries. A number on a line (string) indicates the fret to be fingered to play the note. Guitar tablature can be edited in any ASCII text editor, like this fragment I whipped up in vi:

               ~ ~ ~
   e e e e e e e e e 
E|-1-----5-7-8-8-8-8-|
B|---3---5-----7-5-7-|
G|-----4-5-----------|
D|-------------------|
A|-------0-----------|
E|-4-----------------|

The numbers on the strings indicate the fret positions for the left-hand fingering. Rhythm is here described using letters to designate the rhythmic unit (here a series of eighth-notes), and special symbols are often employed to indicate a guitar-specific playing technique (in this example the tilde indicates a string bend).

Rhythm indication is one of tablature's weak points. You can notate a passage's general rhythm (as in the example above), but it becomes difficult to show the individual rhythmic activities of interwoven lines of music (counterpoint). Notating rhythm is an option, and many available tabs leave it out; like ChordPro, the tab may assume that the player already has some knowledge of the song's performance factors. Indeed, other aspects of meter and time such as time signatures and tempo are similarly not always specified.

The uppercase letters to the left of each line indicate the tuning of the guitar from the lowest string to the highest (from the bottom of the tab to the top). Our example is in standard tuning (E A D G B E), but tab is an superb system for notating guitar music in altered tunings: Simply tune up according to the string labels, follow the tab fingerings, and the music plays itself. Well, that's the theory anyway. All too frequently I discover that there seems to be something wrong with my guitar....

Like ChordPro, tablature is an excellent medium for Internet file exchange. The alt.guitar.tab and rec.music.makers.guitar.tablature newsgroups are excellent resources for learning more about tablature, for finding tab files, and for posting your own tabs. Tablature files are also found on music fan sites and Web pages devoted to song collections by particular artists.

eTktab

Tablature can be written in any ASCII text editor, but Jason Sonnenschein designed his eTktab to truly help the user create original tab files. eTktab produces 4-string bass and 6-string guitar tablatures, edits multiple tabs simultaneously, prepares tab in rhythm or lead guitar mode, and can add precise indicators for guitar-specific playing techniques such as string bends or hammer-ons and pull-offs (legato techniques, for the literati).

The program is essentially an editor optimized for handling tablature files in a native format within a Tk interface (see Figure 6). As mentioned, you could just edit tab files directly in any text editor, but eTktab's tools make the process considerably easier and faster. Figure 7 shows the program working in Lead mode (edits proceed horizontally, no chords can be entered in this mode).

Screen shot.
Figure 6. eTktab At Work.


Screen shot.
Figure 7. eTktab In Lead Mode.

Right-clicking in the tablature display selects an editing area or specific string and fret to be edited. The fret number is entered in the selected space via the keyboard. Cut/copy/paste operations are available via mouse or keyboard control. In fact, eTktab's key bindings are superb, and they are all detailed in the file that appears when you click the Help key. One potentially confusing feature is the Base Fret designator. Fret numbers are entered by typing from the QWERTY keyboard according to these correspondences:

1 corresponds to fret 0 on the 6th string (low E)
Q corresponds to fret 1 on the 6th string (low E)
A corresponds to fret 2 on the 6th string (low E)
Z corresponds to fret 3 on the 6th string (low E)

2 corresponds to fret 0 on the 5th string (low A)
W corresponds to fret 1 on the 5th string (low A)
S corresponds to fret 2 on the 5th string (low A)
X corresponds to fret 3 on the 5th string (low A)

Changing the base fret starts the series at a new fret number. For instance, with the base fret set at "5" our example is now ordered in this manner:

1 corresponds to fret 5 on the 6th string (low E)
Q corresponds to fret 6 on the 6th string (low E)
A corresponds to fret 7 on the 6th string (low E)
Z corresponds to fret 8 on the 6th string (low E)

2 corresponds to fret 5 on the 5th string (low A)
W corresponds to fret 6 on the 5th string (low A)
S corresponds to fret 7 on the 5th string (low A)
X corresponds to fret 8 on the 5th string (low A)

One other note to consider: eTktab saves files in its own et6 and et4 file formats (for 6-string guitar and bass, respectively), but selecting File/Export lets you save the file as a standard tab file. Otherwise the program is intuitive, great fun, and very powerful -- definitely a recommended utility for the Linux guitarist's software toolkit.

Dr. Fermi's Tabulator

Stéfan Fermigier wrote his Dr. Fermi Tabulator to perform an interesting task: It converts a tablature file to a Type 0 standard MIDI file. The process requires some editing of your tabs, but the results are worth the effort. As an example, I chose to edit our second example of tablature made with eTktab. Figure 8 illustrates the changes made to our original file in preparation for conversion by the tabulator.

Screen shot.
Figure 8. Tab Prepared For Dr Fermi's Tabulator.

Some of the commands are obvious, but the lines in this format:

tab E 1 40 64

define the individual strings by note name (E), MIDI channel (1), MIDI key velocity (40), and MIDI note number (64). This style of rhythmic notation

  e  s  s  e   
|----------0--|
|-3--1--3--1--|
|-4--2--4--0--|
|-------------|
|----0--2--3--|
|-3-----------|

defines a sequence of one eighth note (e), two sixteenth notes (s s), followed by another eighth note.

Once the necessary edits have been made, we convert the eTktab example with this command sequence:

[tabul-1.0]$ ./tabul ../eTktab-2.0/my_first.tab my_first_fermi.mid

Figure 9 shows the MusE sequencer running the MIDI file created by this conversion.

Screen shot.
Figure 9. MusE Plays A Dr Fermi Conversion.

The tabulator will warn you if errors are encountered when converting your tab file. Fortunately the documentation clarifies the file format and fully explains how to use the program, so check out the tabulator: It might be just what the doctor ordered.

KGuitar

Mikhail Yakshin has developed his KGuitar as an efficient environment for guitarists to perform common tasks such as writing and reading tablature, finding chord fingerings, converting standard notation to tab, and transposing a song or parts of a song. KGuitar also imports MIDI files for conversion to tablature, and it will export tablature in standard MIDI file format. The program has a number of other amenities that can be applied to other instruments, such as drum tracks and a lyrics viewer.

KGuitar requires KDE2, but can be run outside of the desktop. Figure 10 shows KGuitar in typical operation: note the use of traditional rhythmic notation as well as other elements taken from standard notation (time signature, double-bar at start). Figure 11 illustrates the Chord Constructor, one of KGuitar's coolest features: You can query the constructor for the fingering of almost any chord type and it will respond with a variety of possible forms.

Screen shot.
Figure 10. KGuitar.


Screen shot.
Figure 11. KGuitar's Chord Constructor.

Files created in KGuitar are saved in the program's native kg format; however, you can also save your creations in ASCII tab, GuitarPro (gtp), MusiXTeX (tex), and standard MIDI file (mid) formats. In fact, KGuitar is loaded with nice features, but I could only scratch its surface for this article. It's worth upgrading an entire KDE installation, and I'm looking forward to exploring it in depth.

Tuners

Instrument tuners come in two flavors: fixed-pitch tuners made for a specific instrument, such as a guitar or bass; and chromatic tuners which can tune any instrument. A chromatic tuner can come in handy, even for a guitarist, but we'll stay focused here on some of the better Linux guitar tuners.

gtune

Harold Baur's gtune is a console-mode guitar tuner that's lightweight and easy to operate. Just run ./gtune in the program's home directory, then play your input notes on your guitar, either directly through the line-in on your soundcard (for electric guitar) or through the microphone (for acoustic guitar). Gtune analyzes the input, reports on its true pitch, and indicates whether you're sharp or flat. When you've adjusted the pitch accurately, the display will appear as in Figure 12. And that's it for gtune, short and sweet.

Screen shot.
Figure 12. Gtune At Work.

GuiTune

Florian Berger originally created GuiTune for the KDE environment, but it now has the distinction of being available in versions for KDE, for Qt without KDE, and for GTK. Program operation is identical for all versions: set your input channel (line or microphone) on your mixer and play your instrument through that channel.

You may want to change the sample rate and the threshold level for optimal results; experimentation will find your best settings. GuiTune also provides two intonation sets (equal-temperament in frequencies and just-intoned by ratios), three base scale types, and toggles for representing accidentals as sharps or flats (see Figures 13 and 14).

Screen shot.
Figure 13. GtkGuiTune With Default Settings.


Screen shot.
Figure 14. QtGuiTune Set To Natural (Just) Intonation.

xtune

If all you need is a simple program that plays a requested pitch through your soundcard or through the PC speaker, xtune is the program you're looking for. Xtune is a bash shell script that calls the xmessage utility to create an interactive window for tuning the individual strings of a guitar (see Figures 15 and 16).

Screen shot.
Figure 15. Xtune's Opening Screen.

Screen shot.
Figure 16. The Pitch Display In xtune.

A caveat: The ReadMe file states clearly that the subsidiary applications (the waveplayer and xmessage) must be in your PATH statement, so you will probably need add the following lines to your bash startup script (usually .bashrc or .bash_profile in your HOME directory):

export PATH=$PATH:$HOME/xtune
export PATH=$PATH:$HOME/xtune/wave-0.1 
export PATH=$PATH:$HOME/xtune/xmessage

Start the program from its home directory by running ../xtune. Right-click on the button corresponding to the string you want to tune and the program will play a tuned WAV file in response. You can edit values in the shell script to change the waveform type, the sample bit resolution, and the window colors. The program works, it's easy to use, and that's about all there is to xtune.

Effects processors

This section was definitely the most fun to research. Guitarists love effects processors: The mandatory arsenal normally includes distortion units, echo and reverb pedals, chorus and flanger boxes, equalizers, and so on. I'm happy to say that Linux guitarists will find a variety of software signal processors that include all the effects mentioned, plus a few more rather unusual items. We'll start our tour with a look at the appropriately-named StompBoxes2.

StompBoxes2

Effects processing pedals are often called "stompboxes" (referring to the player's usual mode of operating the device). These pedals are typically devoted to a single processing function, and fascinating effects can be created by freely re-ordering the boxes in the processing chain. Hector Urtubia's StompBoxes2 is a virtual set of pedals that can be chained in arbitrary order, easily simulating the common arrangements used by guitarists.

Currently available modules (virtual pedals) include distortion, volume, delay, flanger, chorus, equalizer, noise gate, mono-to-stereo and stereo-to-mono mixers, and even a unique "reverse" effect. Operation is as simple as the original design: connect outputs to inputs (with any ordering of effects modules), right-click on a module to adjust its parameters, then click the On button to start the chain (see Figure 17). Check your audio mixer to be sure you've selected the appropriate input channel, and start playing. StompBoxes2 has some good DSP algorithms, but the proof is in the hearing, so you should download StompBoxes2 and check it out for yourself.

Screen shot.
Figure 17. StompBoxes2.

StompBoxes2 is great fun, but I found myself wishing that the effects parameters could be controlled in real-time without having to stop playing my guitar, perhaps via a MIDI fader box. However, that is standard operating procedure for most real pedals anyway -- the player sets the effect parameters on the device and does not alter them during play. StompBoxes2 is a highly enjoyable software substitute for a floor covered with real pedals and cables. In fact, it's realistic enough that I caught myself stomping on the carpet more than a few times while testing StompBoxes2.

TAPIIR

Maarten de Boer's TAPIIR is a software multitap delay line. A multitap delay is essentially a delay line (echo unit) with a series of sampling points (taps) in the line's output. The taps feed back through the line output, creating very rich and complex reverberation and echo effects. TAPIIR is a particularly good delay unit with six delay lines and stereo input/output.

The sound quality is very clean, and I recommend running Maarten's two example settings files for a good idea of just what TAPIIR can do. The program's pleasant FLTK interface is easy to navigate and invites experimentation (see Figure 18), and you can save and load your own custom settings files. There's not much more to say here about TAPIIR except that it is an excellent example of high-grade Linux audio software that you simply must have in your Linux audio toolbox.

Screen shot.
Figure 18. TAPIIR At Play.

ecamegapedal

I'm starting to wonder if it's possible to write an article on Linux audio software without mentioning Kai Vehmanen's ecasound and its family of support and extension applications. Ecamegapedal is Kai's contribution to the substance of this article: It's a GUI for applying ecasound's chain operators, effects presets, or LADSPA plug-ins to an audio input file or real-time stream, making it a mega-pedal indeed.

Operation is again a simple procedure: Open the program, select an effect from one of the three tabbed panels, and click on the Start button. Real-time control includes switching between effects and dynamically altering parameters (alas, not yet via MIDI). Ecamegapedal reads audio data from OSS, ALSA, and aRts devices, as well as all audio file formats supported by libecasound (MOD, WAV, MP3, Vorbis, etc.).

Figure 19 shows off ecamegapedal version 0.1dev6 in typical use, reading the input from my CD player and applying the Freeverb effect to the audio stream. Use of ecamegapedal is so straightforward that there's little more to say about it. The author has stated that the software began as more of a proof of concept than a real project, but it is already stable and usable software. Of course I have a wish-list: I'd like to see it incorporate more of the capabilities of libecasound, and it would be very cool to create chains with ecamegapedal itself. Fortunately the author maintains a fast development pace, which is good because I'm already looking forward to the next release.

Screen shot.
Figure 19. Ecamegapedal.

Other interesting software for guitarists

GNU Solfege

Absolute pitch recognition seems to be a born talent, but a musician can cultivate a highly refined sense of relative pitch. Traditional basic musicianship includes ear-training (the ability to recognize pitches and intervals) and music dictation (the ability to notate what you hear), but the acquisition and refinement of those skills is not easily accomplished by the lone Linux strummer at his terminal.

Tom Cato Amundsen's GNU Solfege is the partner you need for practicing interval recognition, singing requested intervals, memorizing rhythmic patterns, identifying scales, and more. It even includes a neat exercise for training your ear to recognize and evaluate 12-tone rows.

GNU Solfege is currently at release version 1.1.3. It is mature software with a well-designed interface (see Figure 20) to facilitate what is sometimes a rather dull and difficult task, but a very necessary task for any musician who wishes to improve his basic musical skills. Consider it an essential part of your toolkit.

Screen shot.
Figure 20. Ear-training With GNU Solfege.

Ecasound

I've already mentioned ecasound in reference to ecamegapedal, but by itself ecasound is a valuable program for guitarists. It's a multitrack recorder, multi-effects processor, and multi-format file player and converter, and its parameters are controllable via internal oscillators or external MIDI controllers. Ecasound can be run from an xterm window or a handy Qt interface in X (see Figure 21) or straight from the Linux console.

Screen shot.
Figure 21. Ecasound With Its Qt Interface.

Snd, GDAM, and AlsaPlayer

When I was learning how to play guitar, I listened to recorded music by way of a strange format made from black plastic or vinyl platters called "records" that were played on a turntable (yes, much like the ones used by your favorite DJ). Happily, many turntables included a control for setting different playback speeds. Thus a 33-rpm (revolutions per minute) record played at 16 rpm would play at roughly half-speed and an octave lower in pitch, making it possible to hear the notes clearly enough to learn and practice the pattern before attempting it at the original tempo and pitch. Unfortunately, although this method worked, the constant replacement of the needle into the record's grooves quickly wore out or damaged the original medium. In other words, I ruined a lot of records.

Lucky you, you don't have to hassle with that sort of scenario. You have the compact disc, and some modern CD players are designed for looping through marked sections of a disc, with separate controls for speed and pitch during playback. With this kind of control, you can slow down a passage without changing its pitch so you can learn the music at its original pitch level but at a more relaxed tempo.

I went looking for something similar in Linux audio software. Alas, I found nothing quite so directly useful as a contemporary CD player, but I did find ways to achieve the same effect. For instance, you can rip a CD track to WAV or MP3 format and work with it in another program. Figure 22 shows the Snd sound file editor with its "expand" control activated and set to 2.00.

Screen shot.
Figure 22. Snd Used As A Looping Player.

When I press the Apply button, the cursor will sweep quickly through the file as Snd performs a granular analysis/resynthesis of the passage. When I next click the Play box the passage will play at half-speed but at its original pitch. If I start Snd with -load examp.scm (a package of functions written in the Guile/Scheme language), I can loop the passage by entering the play-often command in the Listener window. Play-often takes a single parameter that defines the number of times to loop the passage, so a command like this one:

(play-often 5)

will play the file five times through. Believe it or not the procedure is not as cumbersome as it may seem, and users of the emacs editor will find Snd's keybindings familiar and quite fast to utilize.

The GDAM audio processing/DJ environment includes a "respeed" object as well as two different looping mechanisms (see Figure 23). As with Snd, GDAM loads and plays various soundfile formats, including MP3s. Thus you can loop a passage in your favorite MP3 file, use the respeed tool to adjust playback speed without altering the music's pitch, and practice until you've got it right. GDAM is excellent multipurpose Linux audio software -- feature-rich and easy to use, stable and consistently maintained (it's currently at version 0.938). Check it out, I'm sure you'll want to add it to your Linux audio arsenal.

Screen shot.
Figure 23. GDAM In Looping Playback Mode.

By the way, shifting the playback speed without shifting the pitch level usually introduces undesirable audio artifacts, and the required number-crunching often rules out real-time operation. I must point out that the sound quality from Snd's expand control is very good. GDAM's respeed is perhaps not as artifact-free, but it has the great advantage of working in real-time.

Just as I was finishing this article, I received an encouraging word from Andy Lo A Foe, developer of the AlsaPlayer audio media player. Loop play is being developed for AlsaPlayer now, and Andy indicated that it might soon be possible to use his player to loop and time-stretch passages directly from CD. That's just what I'm looking for, so I'll be eagerly awaiting AlsaPlayer's next few releases.

Rhythm Machines: TK-707, Ultramaster RS101, and Rhythm Lab

Drum machines: love 'em or hate 'em, at the very least they are indispensable practice pals when your percussive buddies can't be found (or it's way past midnight). Linux can lay claim to some very nice drum machine emulators, so let's take a look at some of them before we take our leave.

The TK-707 (see Figure 24) by Chris Willing and Pierre Saramito is a great reproduction of the classic Roland TR-707 "rhythm composer." TK-707 works just like its model: Starting the machine sets up a looping pattern of silent beats, you drop in drum sounds on whatever beats whenever you like, and voilá, you have a drum pattern. Patterns are then chained together to create songs, and both patterns and songs can be saved for later recall. Neat and sweet, TK-707 is lightweight and works perfectly. The only problem I have with it is getting away from it.

Screen shot.
Figure 24. TK-707.

The UltraMaster RS101 (Figure 25) is a wonderful rhythm synthesizer/sequencer that provides the guitarist with a bass player, a synthesizer, and a drummer, all in one package. Like TK-707, you set up a looping pattern of beats and drop in events on those beats in real-time. The RS101 is very sophisticated software: The synthesizer is fully programmable and capable of some great sounds, and the drum section is equally interesting. But don't take my word for it, just download it and hear for yourself.

Screen shot.
Figure 25. The UltraMaster RS101.

Like so many useful Linux applications, Aaron Lav's Rhythm Lab was written to scratch an itch: The author needed software that would help him visualize and hear complex rhythms called polyrhythms. Polyrhythm is commonly encountered in modern music scores, and it is a prominent feature of highly rhythmic music such as African and Indian drumming.

Aaron's program enables a musician to set up complicated relationships such as 5 beats in a 4/4 measure (see Figure 26), with complete control over the sounds used, their volume balances, and the overall tempo. Rhythm Lab is a great tool for clarifying the rhythmic relationships in music by composers such as Elliott Carter or Pierre Boulez, and it's a terrific aid in learning how to play those bizarre guitar solos by Frank Zappa.

Screen shot.
Figure 26. Rhythm Lab Set Up For 5 Beats Against 4.

Going out

I hope you've enjoyed this little journey through a relatively unexplored area of Linux audio software development. Perhaps you've found some items you'd like to check out for yourself. If you do try some of this software, be sure to let the authors know what you liked about their programs, and make civil suggestions for improvement where appropriate. Best of all is if you can help with the coding, but there's typically lots of other work to be done in open-source and free software projects. In some respects, programming isn't much different from playing the guitar: The more practice, the more skill, so plug in, tune up, grab some tab, and rock on !

Acknowledgments and References

The author would like to thank Joachim Miltz, Dan Polansky, and Kai Vehmanen for their assistance during the preparation of this article. I am of course responsible for any remaining errors.

Interested readers should see the Linux Sound & Music Applications pages for a complete listing of guitar software, effects processors, notation editors, and other Linux audio and MIDI software.

Dave Phillips maintains the Linux Music & Sound Applications Web site and has been a performing musician for more than 30 years.


Return to the Linux DevCenter.

Copyright © 2009 O'Reilly Media, Inc.