Jon Thysell

Father. Engineer. Retro games. Ukuleles. Nerd.

Month: June, 2013

Introducing Chordious, an app to create your own custom chord diagrams

Chordious IconToday I announce the first release of my latest software project: Chordious, an open-source chord diagram generator for stringed instruments like the ukulele or guitar.

It’s the secret sauce behind the two sets of ukulele chord charts I’ve released in the past month, for both standard and slack-key tunings. At the moment, Chordious is a small command-line app that takes a config file of desired chord diagrams and generates them in clean, beautiful SVG graphics. Whether you want to make some chord charts of your own, or just spice up your song sheets, Chordious is the app for you.

Chordious isn’t just for ukulele, you can create diagrams for any stringed instrument. By default it produces very nice uke chord charts, but you can tweak and adjust the output to make the chords you want. Here are just some of the features:

  • Outputs to clean, scalable SVG images
  • Configurable styling, including:
    • Diagram height and width
    • Font size and family
    • Number of frets and strings
    • Specify top fret and barres
  • Bulk creating from the command line with Chordious.CLI.exe

For download links, check out my Chordious page, or the Chordious project page at Launchpad. You’ll find links for both the binaries and the source. Note that you’ll need at least .NET 4.0 or the latest version of Mono installed to run Chordious.

Happy chording!

/jon

P.S. As of right now the app works, as evidenced by the chord diagrams I’ve already made, but it’s by no means complete. For example I left room in the design for barre chord arcs, but since I didn’t need them personally, they currently don’t do anything. The next big thing I plan to tackle is to a graphical chord designer, to make designing the chords faster and easier. Stay tuned!

Free Slack Key Ukulele Chord Charts and Diagrams (GCEG & Baritone DGBD)

A couple of weeks ago, I released my very own set of standard GCEA and baritone DGBE ukulele chord sheets. I did so partially to make a set of charts that fit my own requirements, but also as a trial run for the software I’d written to generate arbitrary chord diagrams.

To be honest though, my real goal wasn’t to create yet another set of standard charts- what I really wanted was a set of charts for slack-key, or open tuned, ukulele. See, I’ve wanted to try my hand at slack-key ukulele for some time now, but search as I might, I haven’t been able to find a single chord chart online for GCEG, or taropatch tuning. I figured somebody must have done it by now, but all anyone says is “look at slack-key guitar, ignore two strings and transpose” or “just move your 1st string fingering up two frets”.

I turned to books, and bought Mark Kailana Nelson’s “The Uke Buke… Learn to Play Slack Key Style ‘Ukulele”. Not a bad book, but it didn’t even have any chord charts! I bought David Heaukulani’s “Ukulele Slack Key”, which had quite a set of chords in the back, but unfortunately they’re really hard to read- they look like they were photocopied, resized and run through the washing machine. I bought Ondrej Sarek’s “Open Tunings for Ukulele”, which finally had legible GCEG diagrams, but so very few of them.

So I bit the bullet and using the books along with the wonderful ChordFind, I created a new set of diagrams for both ukes tuned GCEG (GCEA with the A string slacked) and DGBD (DGBE with the E string slacked):

Ukulele Chord Chart (Slack Key GCEG) [459k PDF]
Ukulele Chord Chart (Baritone Slack Key DGBD) [459k PDF]
Mini Slack Key Ukulele Chord Charts [1.1M PDF]

Like my previous charts, the first two are each a single letter-sized page (8.5″ x 11″) and contain 120 chords each. The third has both sets of chords, each tuning on half of a single letter-sized page, designed to be folded or cut in half.

And again, like my earlier charts, these are all under licensed under a Creative Commons Attribution 3.0 Unported License. Of course, the package wouldn’t be complete without giving away the individual chord images I generated, for you to do with as you will:

GCEG Slack Key Ukulele Chords PNG [317k ZIP]
DGBD Baritone Slack Key Ukulele Chords PNG [317k ZIP]

Enjoy and happy (slack) strumming!

/jon

P.S. The hardest part of making these charts was my lack of slack-key experience- all I had to work with was chord theory, my own ear and some online tools. I’m sure there are many playing style factors like common shortcuts and chord substitutions that I didn’t take into consideration. (Part of the problem I had with David’s book was that he went ahead and made a lot of the substitutions for you without telling- many of the chords were inaccurate or incomplete flavors of what they’d been labeled as.)

So in making these charts, I altered my previous design rules slightly. First, I went for accuracy over keeping close to the nut, which means more barres and working higher up the fret board. Also, since the outer strings are both the same note, you can swap the fingerings for each and still have the same chord. For these charts I chose the chord shape that was easiest for me to play strumming. However, in slack-key style, which is fingerpicking heavy, the two strings are usually an octave apart, which is something to keep in mind if the music isn’t sounding right.

Finally, like I said before, there are a bunch of substitutions that I don’t know, especially as they relate to fingerpicking patterns, so when looking at tabs or sheet music for actual slack-key arrangements, don’t be surprised if the chords don’t match up exactly. Trust the arrangement, and if you’re a stickler for accuracy (like me), use my charts to look up the actual chord you were playing.

P.P.S. I’ve released the program I wrote to create the images. Download Chordious today!

Free Ukulele Chord Charts and Diagrams (Standard GCEA & Baritone DGBE)

If you search online, you’ll find a ton of free ukulele chord charts for you to print out and enjoy. I’ve collected and used many over the years, but none were ever “perfect” for my needs.

A few weeks ago, I started fooling around with the idea of creating some charts of my own. To that end I started looking for software to help be generate the chord diagrams- but I didn’t find anything with the kind of power and flexibility that I wanted.

So I went ahead and wrote a program of my own. After weeks of tweaking, I’m finally happy with the results.

Here they are, the first versions of my very own free ukulele chord charts!

Ukulele Chord Chart (Standard GCEA) [445k PDF]
Ukulele Chord Chart (Baritone DGBE) [445k PDF]
Mini Ukulele Chord Charts [1.1M PDF]

The first two are each a single letter-sized page (8.5″ x 11″) and contain 120 chords each. The third has both sets of chords, each tuning on half of a single letter-sized page. It’s perfectly portable, designed to be folded or cut in half. Throw a spare in your gig bag!

My design choices included:

  1. Stay close to the nut, opting for open chords where possible.
  2. No chords where some strings aren’t played. (I hate those.)
  3. No marks for barres or finger positioning.
  4. Prefer labeling with flats instead of sharps.

All three chord charts are under licensed under a Creative Commons Attribution 3.0 Unported License. Basically it means you’re free to do whatever you want with these charts, even sell them, as long as you credit me with having made them in the first place.

But wait, there’s more! As an added bonus, I’m also giving away the individual chord images I generated for the charts:

GCEA Ukulele Chords PNG [304k ZIP]
DGBE Ukulele Chords PNG [304k ZIP]

To top it off, I don’t care what you do with these raw images. With the program I wrote, I can create all kinds of custom chord images at will. So, to the extent possible under law, I waive all copyright and related or neighboring rights to these images. Use them in your own charts and song sheets. Use them for education. Use them for commercial purposes. Don’t ask for permission. Give me credit if you feel like it, just don’t take credit because that’s not cool.

Enjoy and happy strumming!

/jon

P.S. Stay tuned for more chord charts in the future!

P.P.S. Yes, I’ll eventually release the program I wrote to generate the diagrams. It’s just not quite ready for prime-time.

P.P.P.S. I’ve released the program I wrote to create the images. Download Chordious today!

Transposing chord progressions with Python

As part of my ukulele practice, I’ve begun creating a small song and exercise book for my own reference. Whenever I start learning a new song, I add the lyrics and chords to my songbook. In the same vein, whenever I find an interesting chord progression, I create a page for it, and list the progression in every key.

For example, I wanted to add a page for the Hawaiian Vamp, or turnaround, which in C is D7 // G7 // C ////. The problem is it’s tedious work, and the tools online, at best, only let you transpose into one new key at a time. So I wrote a Python script to do bulk transpositions:

#!/usr/bin/env python

"""
tChords.py <https://jonthysell.com/>

Copyright 2013 Jon Thysell <thysell@gmail.com>

This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software.

Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions:

1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
"""

import sys
import string

_flats = ["Ab", "A", "Bb", "B", "C", "Db", "D", "Eb", "E", "F", "Gb", "G"]
_sharps = ["G#", "A", "A#", "B", "C", "C#", "D", "D#", "E", "F", "F#", "G"]
_preferFlats = True

def transposeChords(chords, index):
    """Transpose the given chords by the given index"""
    global _flats, _sharps, _preferFlats
    newChords = []
    notes = _flats if _preferFlats else _sharps

    for chord in chords:
        noteParts = (chord[:1], chord[1:])
        if (chord.find("b") == 1 or chord.find("#") == 1):
            noteParts = (chord[:2], chord[2:])

        oldNoteIndex = -1
        if (noteParts[0] in _flats):
            oldNoteIndex = _flats.index(noteParts[0])
        elif (noteParts[0] in _sharps):
            oldNoteIndex = _sharps.index(noteParts[0])

        if (oldNoteIndex == -1): # Not a note
            newChords.append("".join(noteParts))
        else:
            newNote = notes[(oldNoteIndex + index) % len(notes)]
            newChords.append("".join([newNote, noteParts[1]]))

    return newChords

def main(args):
    """Take a progression of chords and print them out transposed."""
    if (len(args) == 0):
        print "tChords.py [list of chords seperated by spaces]"
        print "ex:"
        print "tChords.py C C7 F Fm C G7 C"
    else:
        for i in range(0, len(_flats)):
            newChords = transposeChords(args, i)
            print " ".join(newChords)

if __name__ == "__main__":
    main(sys.argv[1:])

To run this you’ll need Python installed. Just save the text to a file named tChords.py, and launch it from a command line with:

python tChords.py

followed by a progression of chords you want transposed. For the Hawaiian Vamp above, I ran the following:

python tChords.py C: D7 // G7 // C ////

and the script outputted:

C: D7 // G7 // C ////
Db: Eb7 // Ab7 // Db ////
D: E7 // A7 // D ////
Eb: F7 // Bb7 // Eb ////
E: Gb7 // B7 // E ////
F: G7 // C7 // F ////
Gb: Ab7 // Db7 // Gb ////
G: A7 // D7 // G ////
Ab: Bb7 // Eb7 // Ab ////
A: B7 // E7 // A ////
Bb: C7 // F7 // Bb ////
B: Db7 // Gb7 // B ////

Which, with a quick verification against this post on the Hawaiian Vamp, looks correct! The script does come with following notes:

  • It doesn’t care about the starting key, since the goal was to output in all twelve keys.
  • It just blindly replaces the note portion of each chord and keeps whatever modifiers come after.
  • Tip: If you want to know what key each line is in, just begin your progression with the starting key like I did in the example above.
  • If the beginning of a item isn’t a note (capital letter, with or without a # or b), the entire item is kept in the transposition unchanged (like the strumming bars above).
  • By default the script uses flats over sharps (my preference), though you can change that with the _preferFlats flag.

The goal was a quick and dirty script; I only spent about 30 minutes on it, and like all good code, it’ll now make my life just a little bit easier going forward.

Do you find this script useful? Have suggestions or improvements? Say so in the comments!

/jon