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 "trial-and-error" 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 origami-math, 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" — near-alignments 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 more-powerful generations of a program I named *ReferenceFinder*, whose sole purpose was to find short, efficient folding sequences for a user-chosen point or line within a unit square.

*ReferenceFinder* made use of a set of 7 folding operations, known as the *Huzita-Justin 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 hairs-breadth away.

To make a long story short, by the third generation of *ReferenceFinder* (written in 2003), I had incorporated all 7 of the Huzita-Justin 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.

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:

ReferenceFinder 4 comes in executable binaries for Mac, Linux, and Windows. 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 standards-compliant 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! Get ReferenceFinder from the iTunes App Store here.

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., pre-OS X 10.4 on Mac) might need to stick to this version.

- ReferenceFinder 3 Mac executable (.sit)
- 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.