Background
During the development of technical folding that began in the 1980s, a new problem arose for the origami designer: how to find the major creases in the base by folding alone.
This didn’t used to be a problem. In the traditional “trialanderror” approach to origami composition, the design was discovered via exploration of folding. Thus, every crease in the model was created by some folding sequence; it merely required that the designer remember how he/she constructed each crease as he went along. Even if the designer didn’t remember the precise folding sequence, just the fact that there was such a folding sequence in principle made it possible to reconstruct with a little more experimentation.
However, the existence of a folding sequence isn’t necessarily a given with technical folding. It is often the case in technical folding that the proportions needed for the first few folds are defined solely by a mathematical relationship inherent in the design. This leads to a very practical problem: even if you know mathematically where the first two or three folds should go, how do you get them in the right place in practice? This arises over and over in technical folding and was apparent even in the early 1970s in the works of technical pioneers like John Montroll, who strove to give precise folding sequences to define those first few folds, called reference points.
In my own early designs, I had a simple solution to this problem. The coordinates of the key creases could be solved for mathematically, resulting in some algebraic expression. I would evaluate the algebraic expression that defined the key fold to obtain a numerical value for the location of the point or crease, then use a ruler and measure to order. I have published a few designs that demanded exactly this (you will find several in my early books). But this proved unsatisfactory on many grounds, not least because it broke the simple purity of origami needing only a sheet of paper and one’s own hands.
At this point, what had been up to then only a mathematical curiosity — the construction of mathematical proportions by folding alone — suddenly acquired a serious practical application within representational origami. In a series of articles in British Origami Magazine in the late 1980s, I explored some of the different techniques for mathematically constructing geometric proportions and various types of algebraic expressions. My search tapped into a rich field of origamimath, which had already been explored in depth by Justin, Huzita, Fujimoto, Husimi, Geretschlaeger, and many others.
For my own purposes, I didn’t care so much about constructing mathematically exact proportions as “good enough” approximations. For many years I had found folding sequences for starting proportions by a combination of applying the geometric constructions I was aware of and looking for numerical “coincidences” — nearalignments that could be exploited to develop short folding sequences to find the starting proportions for my designs. By the late 1990s, I hit upon the idea of enlisting computer search to help find these short folding sequences, and over a period of several years, wrote successively morepowerful generations of a program I named ReferenceFinder, whose sole purpose was to find short, efficient folding sequences for a userchosen point or line within a unit square.
ReferenceFinder made use of a set of 7 folding operations, known as the HuzitaJustin Axioms. The 7 HJAs describe all possible ways of creating a single fold by forming alignments between combinations of points and lines. By considering sequences of several HJAs, it is possible to find thousands, even millions, of unique points and lines within a square, so that for any given point or line, a short, efficient sequence is just a hairsbreadth away.
To make a long story short, by the third generation of ReferenceFinder (written in 2003), I had incorporated all 7 of the HuzitaJustin Axioms of folding into the program, allowing it to potentially explore all possible folding sequences consisting of sequential alignments that each form a single crease in a square of paper. Of course, the family tree of such sequences grows explosively (or to be precise, exponentially); but the concomitant growth in the availability of computing horsepower has made it possible to explore a reasonable subset of that exponential family tree, and in effect, by pure brute force, find a close approximation to any arbitrary point or line within a unit square using a very small number of folds.
Description
The current version of ReferenceFinder is version 4.0.1. The version history is here.
After program initialization (which takes a few seconds to build the database of folding sequences), you type in a numerical or algebraic expression for the coordinates of a point or a line. ReferenceFinder immediately returns the 5 “best” short folding sequences that approximates that point or line. The approximations are very good, often better than 1 part in 1000, which, in my experience, is about the limit of human folding precision. ReferenceFinder can parse simple algebraic expressions (thanks to a contribution from Carlos Furuti).
The default paper shape is a unit square, but you can change the dimensions for any rectangle (e.g., a silver rectangle or currency). For each solution, ReferenceFinder reports the absolute error in distance, the rank (the number of folds needed), and the sequence of actions needed to construct the desired reference mark. For more details, read the README.txt file that accompanies each of the download packages.
For a few simple examples of some ReferenceFinder references, check these out:
Downloads
ReferenceFinder 4 comes in executable binaries for Mac, Linux, and Windows XP & 7. If that doesn’t work for you, you can download the source code here and compile it for your own favorite platform.
Rights of usage: ReferenceFinder 4 is released under the GNU Public License, version 2, which is included in the source code download. If you have a usage in mind that involves some other form of redistribution, contact me with your desired usage and we’ll talk about what you have in mind.
Downloadable binaries and source code follow:

ReferenceFinder 4 Mac disk image.
Drag the application from the disk image to your Applications folder and you’re ready to go. 
ReferenceFinder 4 Linux installer.
This is a zipped installer script. It is compiled for Fedora Core 6; if you have an older version, you may need to compile from source. 
ReferenceFinder 4 Windows executable.
Unzip and run the executable. Windows may interrupt you with useless warning messages, which you can probably ignore. 
ReferenceFinder 4 source archive.
This has been compiled successfully with gcc 4.0.2 and Visual Studio Express Edition 2005. (Visual C++ is not sufficiently standardscompliant and will complain.) Build instructions are provided for Mac, Linux, and Windows. 
Standalone documentation in HTML format.
Documentation is included in the application (via the Help menu), but if you like to browse offline, download this file, unzip it, and point your browser to the included index.htm file. 
ReferenceFinder 4 for iPhone source code.
Jérôme Laheurte has ported ReferenceFinder 4 to Apple’s iPhone, so you can now find reference points no matter where you are! Update: it’s no longer available in the iPhone store, but anyone is welcome to update the code and recreate it.
The prior version, ReferenceFinder 3, is also available. It is a console tool — you interact by typing in text, and the output is verbal (with a PostScript file of the diagrams). People with really old computers (e.g., preOS X 10.4 on Mac) might need to stick to this version.
 ReferenceFinder 3 Mac is no longer available because Apple no longer supports resource forks in the same way they used to. But you’re welcome to check out the source code (see below).
 ReferenceFinder 3 Linux (i86) executable (.zip)
 ReferenceFinder 3 Windows executable (.zip)

ReferenceFinder 3 source code (.zip)
This has been compiled successfully with Metrowerks CodeWarrior 8 and gcc 3.3.2.
If you run into problems, an updated version of the source code that compiles
with gcc 4.0.2 is here.
The good news is that this software is free and can be used and modified by anyone. The bad news is, there is no warranty of fitness, usability, etc. It may crash your computer (especially if you don’t have much RAM). Use it at your own risk. But I do hope that it works out for you, and if you get some use out of it, drop me a note and let me know how you’re using it.