Recently I had been discussing my edgeriver method (ERM) with several folders on Discord and received fairly good responses. I even began to observe several successful designs emerge from it, so I think it's about time that I briefly write about the subject. My goal here is to give a quick idea of what ERM is all about without going too deeply into the technical and mathematical details. I will assume that the readers are considerably familiar with the tree method (developed by Lang and Meguro, etc.).
Overview
To put it simply, ERM is a generalization of the tree method to any origami design, let it be uniaxial or not. Roughly speaking, the tree method can be thought of as a design process consisting of the following steps:
 Represent the target subject as a tree figure.
 Solve the circle/river packing problem to decide the correspondence between regions on the sheet and components on the tree.
 Construct a flatfoldable crease pattern for the packing, so that the sheet collapses to a base resembling the tree. A general algorithm exists for constructing crease patterns for arbitrary valid packings, but the idea of circle/river packing can also be applied to frameworks such as box pleating, hex pleating, and the 22.5° system.
While this is a very powerful designing method, one of its underlying assumptions is that the desired subject considerably resembles a tree, or a stick figure, consisting mostly of thin appendages. While an animal such as the one on the left in Figure 1 would be a suitable subject, one with a bulky body such as the one on the right will be less suitable (but not impossible, as we do have the notion of elevation and level shifting in the field of uniaxial design, extending the capability of the tree method to broader subjects).
A 3D structure on the other hand, such as the car in Figure 2, is almost impossible to fit in the framework of the tree method. (Notice how we can represent the wheels by 1D flaps since we know we can obtain rounded disks by squashing the flap.)
Therefore, it would be natural to generalize the notion of tree figures to what I call abstractions. An abstraction, roughly speaking (I shall omit the rigorous, mathematical definition here), is a connected collection of 1D edges, 2D polygons, and 3D polyhedrons. (A tree is therefore a special case that consists of only 1D components.) An abstraction can be viewed as the specification given by the designer for the desired shape of the folded base. An example of an abstraction that has all components from 1D to 3D would be a house with a flag on top of it, as shown in Figure 3; the house is 3D, the flag is 2D, and the flagpole is 1D.
(Before we continue, you may want to think about how one might design an efficient crease pattern on a square sheet for this particular abstraction; it's a good exercise.)
Then, we can say that ERM consists of the following analogous steps to those of the tree method:
 Represent the target subject as an abstraction.
 Solve the lake/river packing problem to decide the correspondence between regions on the sheet and components in the abstraction. The solution is called a map.
 Construct a crease pattern (not necessarily flatfoldable, if the abstraction is inherently 3D) so that the sheet collapses to a base resembling the abstraction. A general algorithm exists for constructing crease patterns for an arbitrary valid map, but the idea of the map can also be applied to frameworks such as box pleating, hex pleating, or the 22.5° system.
As the title suggests, we'll be seeing quite a bit of geographical terms in ERM, "lake" being one of them, which I'll explain shortly.
In this article, I will focus mostly on the second part of the process, since the first part is rather straightforward and the third part is too technical for this introduction, but I'll also say a few words about them.
The core idea
To understand the core idea of ERM (and how it gets its name), we need to look back into circle/river packing, on which the tree method is based. The core idea of circle/river packing can be described as follows: each flap must occupy a circular region of which the radius equals the length of that flap, and each nonleaf edge in the tree must occupy a river of which the width equals the length of that edge.
However, circles can also be viewed as rivers that loop back into themselves and enclose just a single point. Thus, we can simplify the formulation above to just the following: each edge in the tree, let it be a leaf or not, must occupy a river of which the width equals the length of that edge.
Also observe that the purpose of a river is to separate the points on its two sides, to ensure there's enough distance between any pair of them. That is, given an edge in the tree, for any pair of vertices on the opposite side of this edge on the tree, their corresponding points on the sheet must also be separated by at least the same distance as the length of that edge. This is due to the fundamental law of origami stating that the distance between points shall not increase after folding.
This fundamental law applies to any model in fact, not just uniaxial models. Consider an edge \overline{AB}
in a general abstraction (either a 1D component by itself, an edge of a 2D component, or an edge of a 3D component). We define a copy of a vertex in an abstraction to be a point on the sheet that will eventually be folded to the corresponding vertex in the base. By this definition and the fundamental law, all copies of A
must be separated from the copies of B
by a distance of at least \ell:=\lvert\overline{AB}\rvert
, meaning there should be a river on the sheet of width \ell
between these two sets of copies. For a copy of A
and a copy of B
with distance exactly \ell
, it is clear that the line segment between them must eventually be folded to \overline{AB}
in the final model. Similarly, we call that line segment a copy of \overline{AB}
. The river corresponding to the edge \overline{AB}
will then flow through several copies of \overline{AB}
. But how does it terminate?
In circle/river packing, a river can only terminate in two ways: either by looping back into itself or flowing to the raw edge of the sheet. In the first case, the river will eventually be folded into a tubelike form on the left side of Figure 4 (one end may contract into a single point). In the second case, the folded river will have an opening, like the right side of Figure 4. These are pretty much the same for the 1D edges in ERM abstractions.
But for edges from 2D or 3D components, things are slightly different. If an edge is involved in only one face (either a 2D polygon by itself, or a face of a 3D polyhedron) in the abstraction (for example, the edge at the abdomen of an openbelly animal, or boundary of a mask), the river needs to connect to the copy of that edge on one end and flow to the raw edge on the other end. Eventually, it will be folded like the left side of Figure 5.
If it is an edge shared by two faces, it will have to connect the copies of the two faces and become something like the right side of Figure 5. It then makes sense to call those copies of faces lakes, since that's what rivers connect to in the real world. I also define the sea to be the raw edges of the sheet plus any unused corner areas of the sheet (which are typically folded under in the first step of collapsing). Now we can formulate the core idea of ERM as follows:
Given an abstraction in which all faces are convex, each face will correspond to a lake of equal size and shape, while each edge must occupy a river (could be of zero length, if it immediately joins two lakes) of which the width equals the length of that edge. The river must either loop back into itself, connect to a copy of the same edge on a lake, or flow to the sea.
(I will cover concave faces in the abstraction such as the side of the car in Figure 2 later.)
I would use the term "edgeriver" if I need to distinguish between the rivers in ERM and the uniaxial rivers in the tree method. It might be tempting to assume that edgerivers behave the same as the uniaxial rivers, such as being nonoverlapping. Actually, things are a bit more complicated for edgerivers, but before we get to that, let's first take a look at a basic example to get a feeling of the core idea of ERM.
First example
Return to the house depicted in Figure 3. If there is no flag, and if it is not required that we make the bottom face of the house, then it would be quite easy to come up with the crease pattern as shown in Figure 6. This pattern is folded directly in 3D and is not flatfoldable, but its structure is considerably straightforward and requires little explanation.
Even for a crease pattern as simple as this, we can already observe ERM in action. In Figure 7, the lakes are in blue and rivers are in aqua. The remaining yellow regions are known as lands, which is defined as any area not covered by water. Back lines are the boundaries of the lakes, rivers, and lands, and red lines are the ridge creases. Naturally, we call such a diagram depicting the distribution of land and water a map. Observe how every edge in the abstraction corresponds to some river (possibly of zero length) in the map, how the rivers change direction as they hit the ridge creases, and how they connect different copies of the same edge.
Conceptual map
Now let's try to bring the idea of ERM one step further, and add the flag to the house as depicted in Figure 3. As we make complicated designs, it is often very helpful to draw conceptual maps first, which are maps that are not drawn precisely and are only for demonstrating roughly how the rivers flow. For the sake of demonstration, let me label the vertices as shown in Figure 8.
A conceptual map can be drawn simply by using pencil and paper, and we don't need any tools or software to do that. Therefore, I will deliberately use my hand sketches for demonstration. Figure 9 is the same as Figure 7 but is drawn conceptually. Personally, I use doublesided arrows to represent rivers in my sketches.
Now, let us imagine how can we add a flag into the design, in particular at the vertex E
. Obviously, right now there's no room next to vertex E
that will allow us to add anything. Therefore, let us create some room by moving the lakes apart. But as we do so, remember that the copies of edges should still be connected to rivers.
In Figure 10, we rotate the lakes corresponding to the roof and move one of the walls away from the rest of the lakes. This creates some empty space in the middle that might allow us to add something in there. But it's easy to tell that this conceptual map is VERY inefficient. Not only now the overall layout looks more like a rectangle rather than our favorite square, but also observe the long rivers connecting that wall to the rest of the model. The key to overcoming this problem is to observe that two copies of the same edge DOESN'T always have to be connected by a single river. Instead, they could each connects to different rivers that both flow to the sea. In Figure 11, we break up the \overline{EG}
river and the \overline{GK}
river, and now things are much better. The overall layout looks more like a square, and we also have more room for the flag.
Now, we know that the flag pole, that is, the \overline{CE}
edge, must also correspond to a river. This river needs the separate the lakes for the house from the surfaces of the flag, so one reasonable guess would be like Figure 12. Notice how the \overline{CE}
river flows across the entire sheet. Also notice how we allocated both the front side and the back side of the flag so that additional paper can be tucked between them.
This isn't so bad, but notice that the way \overline{AC}
river flows seems to prohibit \overline{CE}
river from getting closer to the two \overline{CD}
rivers. We could of course meander the \overline{CE}
river to pack things tighter, but doing so could make the CP more difficult to construct with simple methods. Instead, let us rotate some of the lakes a bit so that things can be more easily packed, as shown in Figure 13.
Not only now the rivers are tighter together, but the overall layout also seems to fit nicely into a diagonally placed square. There are many possible ways we can construct a CP following this conceptual map, and one possibility is shown in Figure 14, in which I slightly adjust the proportion so that everything fits nicely in the 22.5° system. I also doubled one of the lakes for the wall to make the CP symmetric. In this picture, CP is overlayed on the ERM map in gray lines. (The brown lines are for finding references, should anyone would like to fold this model.) And Figure 15 is the finished model.
The main idea here is not about the details of converting the conceptual map to the CP, but about demonstrating how conceptual maps can help us envision possible layouts without bothering the specifics, and how changes in the flow affect the efficiency of our packing.
Lands
Each river has two riverbanks (that is, the boundary curves on the sides), each of which corresponds to one of the endvertex of the edge corresponding to the river. In Figure 14 there are several pieces of land. Each piece of land is enclosed by several riverbanks, and observe that for a particular piece of land, its surrounding riverbanks all correspond to the same vertex in the abstraction. For example, the two largest lands in Figure 14 are both enclosed by E
riverbanks. In this case, we will call them E
lands. Conceptually, a piece of land represents the contraction of a single vertex, which means, roughly speaking, that part of the paper will eventually be collapsed to a small structure near the corresponding vertex. This is especially easy to observe for the E
lands just mentioned by identifying all copies of E around the land, as shown in Figure 16.
Lands come in different sizes and names. Tiny lands are called islands (one common example is the oneunitplug used in box pleating). Large lands are called continents, which may seem like a waste of efficiency but are sometimes inevitable. One example of the continent can be seen in the 12sided preliminary fold (it's like Montroll's 5sided square, only with 12 sides; it can be used to fold an orizuru with 9 heads, for example) in Figure 17, where the continent in the middle corresponds to the top vertex of the base. Despite the existence of the continent, this layout is in fact optimal. It just happens to be the case that we don't need any extra features there for this particular abstraction. For models like this, the main challenge is to collapse the continent in such a way that the resulting structure is as thin as possible while also being small enough to not get in the way of other structures.
But perhaps the most important type of land in ERM is the peninsula, which is closely related to the notion of concavities in the abstraction. In the 2D case, we say that two edges in an abstraction form a concavity if the angle between them (on the side of the model) is greater than 180°. (In the 3D case the definition is more complicated, which we shall omit here.) Figure 18 is an example of an abstraction in which edge \overline{AB}
and edge \overline{AC}
form a concavity at A
.
In most cases, by having a concavity in the abstraction, we implicitly specify that the negative space should be completely cleared out, and no extra layer should be exposed. In that case, the rivers corresponding to the two edges forming a concavity must not share riverbanks (it is allowed that the two rivers touch at a corner, but not on a segment of nonzero length), otherwise, it will be impossible to completely clear out the negative space (assuming that we want to fold the model flat), and some extra layers will always be exposed no matter how much we try. In particular, if those two rivers flow in parallel, then we must leave a gap between them in order to avoid those layers that I call connectors, which is defined as any visible layer in the folded base that is not part of the original abstraction. This gap naturally becomes a long, narrow land between the two rivers, which is what I call a peninsula.
The interesting question is, how wide should the peninsula be to make it work? Perhaps surprisingly, as long as there is a peninsula of nonzero width, no matter how narrow, there exists a CP that can fold it flat without connectors! However, the catch is, the narrower the peninsula, the more creases it will need to get rid of the connectors, and the local thickness can approach infinity as the width of the peninsula approaches zero! So although a narrower peninsula implies better efficiency, which technically means fewer layers on average over the sheet area, in this case pushing the efficiency actually means thicker layers locally!
So typically, we will use a peninsula not too wide that it wastes efficiency too much, but also not too narrow that it becomes too difficult to fold. For box pleating, it makes perfect sense to use a peninsula of 1unit width ^{1}. To demonstrate, consider folding the abstraction in Figure 18 on an 8 × 8 grid using box pleating. Since \lvert\overline{AB}\rvert=3
and \lvert\overline{AC}\rvert=3
, it may appear that it suffices to have those two edges connect to rivers of width 3 and have copies of B
and C
stay distance 6 apart, but in fact, that's not enough since A
is a concavity. So we add a oneunit peninsula between them, and an 8 × 8 sheet just happen to have enough room to fit them all by using Pythagorean stretch between B
and C
. The result is shown in Figure 19. Notice that peninsulas are usually filled with zigzag crease patterns in the CP (but it may also not be the case due to crease transformations).
In my Sauwastika (shown in Figure 20), observe how the 8 marked concavities in the abstraction correspond to the 8 peninsulas in the map. Also notice that in four places the pair of rivers forming the concavity touches at one corner, which is allowed as mentioned.
Overlapping rivers and waterfalls
Perhaps what's more surprising than peninsulas is that in some other cases, edgerivers can actually overlap. This is impossible if all components in the abstraction are 1D (that is, the abstraction is a tree), but as long as it has 2D or 3D components, chances are that we could utilize the interior of these components to overlap the rivers for better efficiency.
One simple example is demonstrated in Figure 21. Here we are trying to create the abstraction on the left on an 8 × 8 grid. Using our previous knowledge about the concavities, we can quickly convince ourselves that the only possible way to allocate the lakes (assuming that everything is under the framework of box pleating) is by putting them at the locations shown in the middle map. However, by doing so, the \overline{AB}
river and the \overline{AC}
river seem to overlap in the shaded area. Surprisingly, such overlapping is in fact legal, because the shortest distance between B
and C
(as we travel inside the model) is not 4, but \sqrt{8}
, so as long as copies of B
and C
stay apart in such distance, overlapping of the river is perfectly fine. The final CP is shown on the right.
In other words, if two edges form an angle less than 180°, then they will be allowed to overlap to a certain extend depending on the angle. This is a very useful fact to keep in mind, as it can often help us to squeeze rivers into tight spaces. However, this can also make the map difficult to read as any part of the paper can have more than one role. In some cases, the overlapping can be simply represented by a shaded area as we did in Figure 21 without causing too much confusion. But in some other cases, overlapping can be quite large and complicated, and it is even possible to have a river overlapping with a peninsula (depending on how one interprets the role of that part of the paper).
In order to make sense out of complicated overlapping, I came up with the notion of waterfalls. A waterfall is a line on the map, which has the magical property of teleporting a river from one place to another. To demonstrate, consider the abstraction on the left of Figure 22, and a CP that folds to flat to that abstraction in the middle (for the abstraction in question, this CP seems less than optimal in terms of efficiency, but that is because this example is part of a larger design, and there are other considerations on the outside). What should be the underlying ERM map of this CP?
Most of the edges in the abstraction can easily be mapped to rivers as shown in the partially completed map on the right, except for edges \overline{AB}
and \overline{AC}
. One might expect that they correspond to two rivers traveling in the area with a question mark on the right somehow to connect the copies of those edges. But if we carefully examine the actual structure resulting from the CP, we will realize that the copies of these two edges actually each emits a single river that escapes to the sea while overlapping other rivers in a complicated way as shown in the left of Figure 23.
Such representation is clearly terrible as it requires lots of arrows to indicate exactly how the rivers flow. In contrast, the waterfall representation on the right is much cleaner and easier to understand. In this picture, waterfalls are the purple lines. We imagine that when a river enters one part of it, the river gets teleported to the other part of the waterfall. So now both edges \overline{AB}
and \overline{AC}
correspond to a single river each. (I draw arrows in this picture for clarity, but in most cases, the purple line alone is enough to indicate how the river gets teleported.) What happens in the actual fold is that the two parts of the purple lines will be folded together so that two river segments will be joined facetoface instead of being reflected by a ridge crease.
Backside lakes and swamps
Now let us go back to one question raised earlier: what should we do if there're concave faces in the abstraction? There're several possible solutions. The first and perhaps the most elegant solution is to use curve folds and allow curved surfaces to create the appearance of concave faces (the definition of the abstraction can be generalized to cover curve folding as well) without adding any additional edges, or "seams" to the face. The second solution is to divide the concave face into convex subfaces and work from there. Doing so will add seams to the original face, which may or may not be aesthetically acceptable. The third solution applies only when the concavity of the face results in the face being partially covered by another face, as shown on the left of Figure 24.
In the abstraction on the left of Figure 24, one of the faces seems concave, but if we imagine that it actually has a hidden part underneath the other face (as shown by the dashed line; I don't usually draw those on abstractions, I do it here only for clarity), we can then treat it as a convex face and do our usual ERM thing. In order to make sense out of such a structure, we need to add another triangular face in between them, which can only be seen if we "open up" the abstraction into the net (as in "net" in the context of geometry). The lake that corresponds to this hidden face is known as the backside lake.
After adding the backside lake, we can then continue in the same way as before to create a CP such as the one on the left of Figure 25. In the middle we can see a map that is more a precise interpretation of the CP, where the usage of waterfalls faithfully reflects the structure of the actual CP, but such a flow can be a little too complicated to foresee in the beginning. In this case, I prefer to use a map with simplified rivers as shown on the right, which captures the essence of the layout without being overly precise. It is also the kind of map I will draw for the abstraction in the conceptual phase of the designing process.
Whenever we try to draw the ERM map for a CP, there's always the question of how precise we want the map to be. We want to map to reflect the actual structure as much as possible, but we also don't want to be too precise that the map obscures the essence of the layout. I tend to go somewhere in the middle where I feel the right balance is hit between the two goals.
Now we have seen how adding a backside face to the abstraction can help us handle abstractions in which some of the faces are stacked on top of the others. However, a backside face does not necessarily have to be allocated as a single, seamless lake in the map. Since the face is hidden in the finished model, we usually won't mind if it has seams on it. Therefore, we may allow the backside face to be formed by combining multiple smaller lakes.
Why would we want to do that? Although a single backside lake is easier to grasp in concept and is easier to plan the layout, it does have the disadvantage of putting a lot of restrictions on possible layout solutions. By breaking the lake into smaller pieces, we have greater freedom in possible layout, and in some cases, doing so is the only way to make things fit into the desired grid size.
For example, consider designing the abstraction on the left of Figure 26 on an 8 × 8 grid. With this grid size, the locations of the three lakes are uniquely determined, and there's no room to fit in a backside lake ^{2}. So instead, we split up the backside face into a swamp, which is indicated by the dark green region. That area will eventually be folded into the backside face, with one seam on it. The corresponding CP is shown on the right.
As a remark, one might notice that the overlapping rivers in Figure 21 can also be reinterpreted using a backside lake instead. It is true that in many cases, the same CP can be interpreted differently. The reason why I would personally choose the overlapping river interpretation is that to me, the backside lake is not readily suggested in the given abstraction, and I don't want to give the impression that one must be able to foresee the usage of the backside lake in order to come up with the map.
Applications
When one tries to apply ERM in designing, the first step is to draw an abstraction. In some cases (for example, when applying ERM to 22.5° system) the abstraction can also be conceptual, but for grid systems like box pleating or hex pleating, a precisely defined abstraction is preferred. In order to figure out the proper dimension of the abstraction, I often make papercraft models with scissors and glue to test if the abstraction can be shaped into a model of proper proportion to the subject. We also need to specify all hidden details of the abstraction, such as backside faces, numbers of digits or overlapping appendages, etc.
The second step is to plan the layout, starting by drawing conceptual maps. Once a conceptual map looks promising, then we can try to precisely allocate the elements on our sheet. The exact location of the lakes can be determined by considering the necessary distance between the vertices (i.e., consider how far it takes to travel from one vertex to another on the model, plus the necessary extra distance corresponding to the concavities). In box pleating, one must also consider the effect of the parity principle, which states that any two copies of the same vertex must have an even taxicab distance (otherwise, halfunit structures will have to be used, which may or may not be desirable).
The final step is to convert the map into a mountain/valley CP, the detail of which is too lengthy for this introduction. But at least for box pleating, many of the patterns are already wellknown, such as rivers will become inandout pleats and peninsulas will usually have zigzag creases. When in doubt, one can always make a test fold on selected regions to figure out a working CP by trialanderror. And in the most general case, there's always this general algorithm for converting an ERM map to CP as the last resort, which is very similar (with a few additions) to the Origamizer algorithm introduced by Tomohiro Tachi.
I've been using ERM in my own designs since 2014, from midlevel complexity to supercomplex models. One of the most ERMintensive designs is my Domestic Shorthair Cat, of which map and abstraction are shown in Figure 27. It combines all ingredients we've introduced so far: peninsulas at concavities (many of them are 2unit wide for the fact that 2unit wide pleats are used nearby, or for strategical reasons), backside lakes and swamps, overlapping rivers and waterfalls, and 3D structure at the ears. One may compare it to the CP and folded base in Figure 28.
Another recent ERM design of mine is the Angelfish, as shown in Figure 29. In this design, the abstraction has more edges that are not orthogonal to the grid. This requires more sophisticated planning of backside faces in order to fit into the framework of box pleating. Thanks to the power of ERM, I was able to get a very satisfying proportion in the final model.
It is worth pointing out that in both Figure 27 and Figure 29, there are many places where simplified representations are used. For example, near the upper left corner of Figure 29, technically it really should be two overlapping rivers, as shown on the left of Figure 30. To me that's a bit unnecessarily precise, so I represented them as a single river that covers two edges in the abstraction.
Final words
That's all for the introduction. I would like to thank all my friends who helped me refine the ideas and presentation of ERM, especially Drew Heskett and Brandon Wong. Drew has also been very successful in applying ERM in several of his own designs. I hope ERM will inspire more designers to create models previously difficult or impossible to fit into the uniaxial paradigm.

In some cases, it might be necessary to use 2unit wide peninsulas due to the parity principle of box pleating, which will be mentioned later. ↩

At least not by placing it along the grid. In this example, it is in fact possible to rotate the backside lake at a rather random angle to fit in the space, and we can continue to construct the CP using the general algorithm. But doing so will result in a CP very difficult to precrease. ↩
Great article. I really hope you publish a second part of this article soon. I think it is meant to be a revolution in origami design. I will try to put these ideas in any of my future designs.
Thanks! Right now I’m working on BP Studio again, so I might not be writing for a while, but I’m sure I will write more on this subject in the future.
Absolutely incredible to read. I feel like I’ve been using some basics of ERM without knowing what it is or how to use it intentionally, I’ve created a very similar simple house, for example, but that can hardly be considered a feat. 😅
I love that this method is more universal than the tree method and that it can cover models with large flat areas, added surface texture details and even 3D folded shapes as well.
I’m pretty sure that various designers had come up with similar intuition for nonuniaxial designs in the past. The only thing I’ve done here, if anything, is just formulating things down 😉