Site hosted by Build your free website today!

Site Map

Navigate Software
Main Software Page
EZ-AV Tools for Unix

This Page

Lovely Counter

free hit counter
(Reset from about 10,000 in April 2005 by a crash)


Patel is a simple software-based (audio) synthesizer, named after the TV character "Synthesizer Patel" (partly as a homage to the great musechnologist, and partly because names for projects are so bloody hard to come up with).
[NOTE: That means if you got here searching for a page about the TV character, you should probably keep searching as this is just a geeky software project, and an incomplete and non-interactive one that probably doesn't run on Windows yet, for that matter. Sorry]

There are quite a few soft-synths out there, free or otherwise (Patel is free), but the general rationale for Patel was:

  • It should be conducive primarily to making "chiptune" style sounds and music (I'm not sure if I've taken the right approach for this yet)
  • It should run on a lot of different platforms (doesn't yet)
  • It should be efficient and lightweight enough to be able to run well even on very old, low-power or otherwise slow hardware, with plenty of slack (this is the reason so many of its algorithms use fixed-point maths and why in various places effort has been spent on minimising LUT size; no benchmarking or profiling has been done yet though)
  • It should be implemented as a library to link into other software rather than as a single stand-alone program (currently it is a standalone program though :P)

Patel is (almost?) entirely written in ANSI C, except for some external utilities written in Perl. It works (insofaras it works at all) on Linux; making it work on other platforms will require me to change which packages it depends on for output (libSndfile doesn't seem able to be cross-compiled), which is something I shall get to in due time.

NOTICE: Sure enough, there later turned out to already be at least two or three other formats out there using the "PPF" file extension, not just the format I made up for my synth- yet this page is coming first in some peoples Google searches on the subject. So if you came here to find out about "PPF files", this probably isn't the page you want, unless it's for use with my synthesizer program here. Sorry, I didn't know. Using 3-letter-acronyms for naming file types is a stupid idea.


Patel is really very incomplete currently. This should be considered a pre-alpha release. It is eventually supposed to be made into a library, but it is currently in the form of a small prototype executable that uses the synthesizer code, in order to work more easily on it. The prototype isn't interactive, although when it is turned into a library it should be.

The synthesizer itself works to the extent that it can produce sound (currently just output to disk as WAV files), but large chunks of it are missing and some parts are rather cobbled-together.

The current prototype uses a simple parser to read a very primitive file format (currently named "PPF" for "Patel Packet Format", in lieu of anything better) of my own design to describe settings, instruments and music. Given an appropriately constructed PPF file it will produce the WAV file of the synthesized tune well enough (except where the features described aren't implemented), but the files are nasty for humans to work with. The PPF format was designed for the computer to be able to read and write without too much trouble, and to be easily adapted if redesigns of the synth warranted it or minor details of the format turned out to be badly thought out.

That idea was probably a good one (kind of), but meanwhile it's still horrible for people to write unless they know exactly what they're doing, and even then it's hardly the ideal mode of musical expression! This fact should be mitigated by a set of external utilities for creating and modifying PPF files, but as it turned out I only made one such program, which takes a more human-friendly score file (of lines of plain text with human-readable note identifiers etc) and turns it into a PPF file describing that tune played on one channel with one instrument (a basic default instrument).

With the other utilities (eg: a channel multiplexer, something for concatenating tunes together, an instrument remapper, etc), it wouldn't be too hard for users to make much more complicated tunes from such primitive building blocks. Unfortunately by the time I finished creating the library for the utilities to parse and write the PPF data with, I was quite fed up with working on Patel and couldn't marshall the willpower to write any more of it.

I want a break, but I wanted to release an early version of this project like a month ago or something. So here's a barely useable version for the moment, I'm going to do some other things for a while (a few weeks? Months?), and then I'll come back to do those utilities, before working on the various other things that are missing from the project.

If you want to be informed when the next release (and any others) is made, and you have an account there (it's free), you can subscribe to Patel's new Freshmeat project page. This also helps me know how much interest there is in the project.

Download Patel

Here is everything there currently is to download for Patel: the source code to the program (and to the PPF library which it currently works with), and some tunes and random noises I made with it.

The synth itself:
If you want to play with the synthesizer, you will need to:
  • Build and/or install the development libraries for libSndfile, which Patel currently uses to create WAV files
  • Download the current source code for Patel and unpack it somewhere
  • Compile Patel, which will need a C compiler and development environment (as will building libSndfile if you can't get a prebuilt version). You may need to edit the Makefile perhaps, and I have no idea if it will work on Windows.
If all that works, it's quite likely you will then find yourself unable to work out how to use the damn thing. Sorry. Documentation will improve as the project progresses.
Download the source code at last:
Source code for Patel version 0.01
Later there'll probably be binary versions for various platforms, but that'll have to wait till the whole thing can be cross-compiled (mostly a problem with the other libraries Patel uses, it seems).
NOTE: I accidentally put the license as "GPL" at first, this was an oversight. The license should be "LGPL", as Patel is designed with the intention of turning it into a library. Nobody seems to have downloaded the thing yet, and in the meantime I fixed this.
Other crap:
Despite its current faults, Patel is still able to create music. The fact that I know how to do it is only because I wrote the thing and therefore know how the PPF input files work. In future I'll document them properly but by then there should be more useful programs to process them (Eventually Patel will abandon PPF files and just become a library that you can make your own programs to control).

Anyway, here's various little examples, all in the free Ogg Vorbis format. They're mostly unmusical I'm afraid :D

  • The first command-driven output, which was absolutely horrible as there were still so many bugs. This isn't recognisable as anything except noise, and is literally quite painful, you don't want to hear it. Don't say you weren't warned!!
  • The first correct command-driven output, which is a bit buzzy (because it's using a square wave based instrument) but vaguely musical. I was very pleased with it because it showed things were working at last :)
  • The first output with frequency modulation on an instrument. Not musical but I thought it was kinda cool anyway.
  • A test with a rising series of notes, with an instrument using ADSR envelopes. Note that there's some percussive sounds at the very end that are the result of playing a note just out of Patel's range. Not the first of these to use envelopes- I think I used them previously in earlier versions of the following file:
  • A very random "tune" with various different instruments. I kept adding to this over the weeks of development, to test numerous things.
  • The first thing I put on the web, because it was an actual test tune. I don't remember if I created this one using the "" script or if I did it all by hand, but the timing was noticably a bit off. A few hours later I had made a version that was right (and which I did use that script to produce), but I'd already uploaded this and decided to leave it there in all its arhythmic glory.
No, none of these are of any musical merit (no offence meant to Deep Purple) but they give a general indication of the development of Patel and of what sorts of things it's capable of currently. I wish there was something much cooler, but that'll have to wait for some future version.


June 17 2005:Looking at my hit counter logs, noticed there were a couple of hits from people googling the PPF format. Checked the results of such searches, and of course there turned out to be various others. Put up disclaimer at top to explain that the PPF format described here is PROBABLY NOT the one they're looking for! Bleh.

Ooh! But also saw a hit from a machine on the BBC network, how cool! Hope they don't object to the project name, I don't think there's much reason for them to.

June 1 2005:Reuploaded version 0.01 before anybody downloaded it, to fix the copyright info: it is licensed under the LesserGPL, not the full GPL, as it is intended for use as a library, even if it isn't one yet. Yes, I'm allowed to change the license as so far I'm the sole author.
GAH, then remembered to fix the FAQ in that regard too; At least the project submission went through Ok after a little while.

May 31 2005:Finished tidying up the few docs, packaging up version 0.01 of Patel and making a few edits to this page, uploaded it all at last.


May 29 2005:Decided to just upload Patel without most of the utilities, then plugged away for some hours writing this webpage, compressing some of the uncompressed test tunes I had sitting on my hard drive, and fixing up some of the documentation.

May 26 2005:Got most of the PPF library done, messed about testing it with a simple program for reading in a PPF file and writing it again (which produces a file that is different but which works the same). Found it worked pretty well, but wasn't especially easy to work with.

May 19 2005:Struggled with making a PPF parser+writer library for Perl, for making the rest of the utilities with. Eventually got so angry and fed up about the obscure and unfathomable bugs in it that I decided to give up on coding it in Perl and do the same thing in C instead.

May 12 2005:Decided to work on a set of utilities for creating/modifying PPF files at last, As first of these, made "", a Perl script for turning reasonably simple score files into PPF that Patel can use. Very simple, worked nicely.

Late March 2005:Gave in to my long-running urge to create a simple chiptune-style synthesizer, which had mostly been the result of wanting to see if envelope shaping and amplitude modulation were as straightforward as I'd suspected. Decided to call it "Patel" after Synthesizer Patel, and started work.

These pages created and maintained with MMSS (Make My Static Site)