Extracts from several messages pertaining to O.I.L.

    The language has two parts which occur in each step:

   (I) Definition matrix--a formal statement in rows and columns
      uniquely identifying the points on the boundary or elsewhere
      of the model so far and defining any new locations needed for
      the next fold(s).  To a certain extent the matrix can be used
      to check the accuracy of what has been folded so far.

   (II) Fold Instructions-- Usually these consis of identifying the
      two points which are to be brought into coincidence by a fold
      (or folds).  On occasions two lines may be specified or a
      mixture of points and lines.

Well, I was interested, and Bob sent me a copy of the paper. It's about 27 pages long, but I'll see if I can put in a short example.

This is the preliminary fold (DM == Definition Matrix which defines the corners, FI == Fold Instruction):

Step 0:

   DM                               1


                             2             3


                                    4

   FI:                       1
                      1 ------------> 4

Step 1:

   DM:
                    _               _
                    1               2


                           3

   FI:
                           2
                 1 -----------------> 3
                           1


                           2
                 2 -----------------> 3
                           1

That's a *very* simple example. In addition to the corners, you can designate other parts of the paper by saying something like A = 1/2(1-3) (A is the point halfway along a line between point 1 and 3 -- this is not necessarily a point on an edge).

Now this is all a big pain in the neck to type in by hand, and probably too baroque to decode by eye, particularly since the summary of the symbols is 4 pages long, and includes ways of designating diagonals (that may cross at angles other than 90 degrees), enclosed areas, approximate point locations, number of layers in the definition matrix, etc., etc.

On the other hand, it would be relatively simple to write a program to translate O.I.L into diagrams. These diagrams combined with the usual step-by-step commentary would probably be sufficient. Getting folds into O.I.L. would be a little tougher, but I could see how it might be done with a specialized origami diagram drawing tool (it would be a fun three-week lispm hack... too bad I'm working on a degree at the moment).

This is probably more than anyone wants to know about O.I.L., but there you go. If anyone is really interested, send me some mail, and we'll discuss how to get it to you (I'm a broke grad student, or I'd offer to xerox it up and send it out to everyone who wanted it).

The only reference I have to code that allows one to specify an origami model is in Peter Engel's "Folding the Universe."

Here is a paragraph about it from the book and
the reference: (w/o permission, of course)

   " It happens that a system has already been devised for
     converting folding diagrams to a numerical notational
     system, John Smith's Origami Instruction Language (OIL).
     Smith, a British statistician and computer programmer,
     uses a Cartesian coordinate system to locate points on
     the square and identifies a crease by the two endpoints
     it connects. The success of Smith's system ensures that
     establishing a purely numerical representation for each
     model is possible....       "

Alice Gray, "OIL: John Smith's Origami Instruction language," The Origamian 13, no.2, (n.d.), p. 1.
I think it is a good idea to have software that can communicate folds on a sheet of paper graphically, but it could become extremely cumbersome or nonfunctional for complex models and when thickness becomes an issue.

Last update: 13 August 2008