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
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
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
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:
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.
- 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.
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.
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
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.
- 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
- 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 "notestoppf.pl" 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.
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
Freshmeat.net 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
"notestoppf.pl", 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.