JFugue is an open-source Java API for programming music without the complexities of MIDI. Read that again. WITHOUT the complexities of MIDI. It's all pretty simple, as you'll see. Let's get our feet wet by opening some MIDI file into a Swing application and then... we will change the music file AND play it!

So, just create some kind of Java application and attach jfugue.jar . Next, let's add a JFrame , we'll call it "MusicFixer". We'll declare the magical Player object, which will do all the heavy lifting (i.e., loading, playing, and saving music) for us:

Player player = new Player();

Next, add a JTextArea to display music files, a JButton for opening them, and a JButton that will do the playing. For example, in your GUI designer, all that could look as follows:

Now we'll add some code to the Open button's actionPerformed event:

File midiFile = null;
JFileChooser fc = new JFileChooser();
int returnVal = fc.showOpenDialog(this);
if (returnVal == JFileChooser.APPROVE_OPTION) {
    midiFile = fc.getSelectedFile();
}

Next, we'll add some code to the end of the same event, this time for setting the content of the JTextArea with the content of the Midi file, which is a segment of music, represented by the Pattern class:

try {
    Pattern pattern = Player.loadMidi(midiFile);
    jTextArea1.setText(pattern.toString());
} catch (InvalidMidiDataException ex) {
    ex.printStackTrace();
} catch (IOException ioEx) {
    ioEx.printStackTrace();
}

Ok. Run that puppy, click that button, and open some MIDI file. Tada... this is what you see (or something like it):

Good for you! You've just opened a MIDI file, and can see its internals, using JFugue notation to represent the music embedded in the MIDI file. Let's now... play that music!

In the actionPerformed event of the Play button, shove these two lines:

Pattern pattern = new Pattern(jTextArea1.getText());
player.play(pattern);

Hurray! When you run the application, those two lines will do what 20 or more lines would have done for you in the Midi API. But, that's all well and good. Let's now change the music. Here's a handy class, called PatternTransformer , for playing our music an octave lower:

PatternTransformer octaveTransformer = new PatternTransformer() {
    public void noteEvent(Note note) {
        byte currentValue = note.getValue();
        if (currentValue > 12) {
            note.setValue((byte) (currentValue - 12));
            returnPattern.addElement(note);
        }
    }
};

Cool. Now, how to play it? Couldn't be simpler. Get the content from our JTextArea , pass it to our transformer, and then play the pattern that the transformer comes up with. Thus, our Play button now has this content:

Pattern pattern = new Pattern(jTextArea1.getText());
Pattern octaveLowerSong = octaveTransformer.transform(pattern);
player.play(octaveLowerSong);

And that's it. Click your Play button again and your music is an octave lower. For all this and much (much) more, see JFugue: Java API for Music Programming . At the very least, you'll have fun! At most, it'll be educational and you'll be productive at the same time. The javadoc will give you most of what you need to get started, together with some basic samples .