Hello, Rabbit Ear

Code that can virtually fold origami? Say hello to Rabbit Ear.

ray fold

What’s all this now?

This is a creative coding library, like Processing or Open Frameworks. It’s not an application like other origami software, but it can be used to build apps, or sketch out a parametrizable design idea in a few lines of code. Check out some examples:

Wait there’s other origami software?

TreeMaker (‘94), Oripa (‘05), Tess (‘05), and Origamizer (‘08), and those are just the design oriented ones.

What makes Rabbit Ear different:

  • It’s cross-platform Javascript (Mac, PC, Linux, mobile, Chromebook), it runs in the browser.
  • It doesn’t do one thing, like how Treemaker makes uniaxial bases, it’s a general purpose design tool.
  • Interface design isn’t often emphasized in academic software. Good design makes software accessible, inclusive, and can better introduce origami to newcomers.

🍭 It’s free 🎉 open source 🔬 and extendable 🔮

open file

fold file

inside a crease pattern file

The community is still working on the best way to store an origami design. This library supports the latest solution which stores vertices in space which can lead to the epsilon problem above.

One idea that this project has inspired: imagine instead of points, you stored the folding sequence - the choreography or dance that gets you to the final shape. Imagine a computer performing a folding sequence. And just like music, a performance allows freedom for interpretation, and conversation around what makes a good performance.

J.S. Bach's Invention 4

A simple example: the kite base

  1. fold in half diagonally
  2. fold the two bottom edges to meet the diagonal line

kite base

How can this take shape in code?

crease_a is the diagonal_fold
valley_fold(from: bottom_edge, to: crease_a)
valley_fold(from: right_edge, to: crease_a)

creases are the product of operations, and can be used as parameters in other methods.

kite_base (polygon, point)
  angle = polygon.interior_angle(point)
  bisections = polygon.bisect_angle(angle)
  for a in bisections:

a kite base is actually three angle bisections.

kite_base (square)
  new_edge(square.vertices.0, square.vertices.2)
  v1 = new_vertex_between(square.vertices.1, square.vertices.2)
  v2 = new_vertex_between(square.vertices.2, square.vertices.3)
  new_edge(square.vertices.0, v1)
  new_edge(square.vertices.0, v2)

a graph approach

Which brings us to the current implementation of this library in Javascript.

// crease the diagonal, hold onto it
var diagonal = origami.crease(0, 0, 1, 1)

// fold an edge to an edge (axiom 3), mark them as valley
origami.fold(origami.leftEdge, diagonal).valley()
origami.fold(origami.bottomEdge, diagonal).valley()

Central to this project: always be returning to the drawing board to ask: can the computer interface be more intuitive to beginners?


This release marks the moment this tool is basically functional, I’ve begun using it in my own designs, but it’s just the beginning. If you feel like contributing to the source it’s currently on Github and you can download Rabbit Ear here.

Happy coding!