origamisimulator.org

Open origamisimulator.org in a WebGL-capable browser, load a crease pattern from the Examples menu or upload your own SVG/FOLD file, then drag the Fold Percent slider to fold it. The simulator folds every crease simultaneously rather than in sequential steps: 100% is fully folded, 0% is flat, and -100% is fully folded with mountain and valley assignments reversed. Drag to rotate the model and scroll to zoom. When the folded shape looks right, use File > Save Simulation as... to export a FOLD file or an STL/OBJ 3D model.

Before You Start

• Browser: The app is a real-time WebGL application, so you need a browser with WebGL support. All rendering and 3D interaction run on three.js.
• Input format: Crease patterns must be in SVG or FOLD format. The site links to its own import instructions, which are worth reading before your first upload — curved crease patterns in particular are pre-processed with a ruling-aware triangulation method so the bending between creases looks realistic.
• What "folding" means here: The solver iteratively computes small displacements of an initially flat sheet caused by crease forces, running in parallel GPU fragment shaders. You are watching a physical relaxation, not a step-by-step folding animation, so the motion can look organic rather than instructional.

Step-by-Step: Fold a Pattern

1. Load a pattern. Open the Examples menu and pick a built-in crease pattern, or upload your own SVG/FOLD file. Starting with an example is the fastest way to confirm the app is rendering correctly on your machine.
2. Set the fold degree. Slide Fold Percent to any value between -100 and 100. Watch how the sheet moves: intermediate values show partially folded states, which is useful for spotting creases that behave unexpectedly.
3. Inspect the shape. Drag to rotate the model and scroll to zoom. Check both sides of the sheet — a reversed mountain/valley assignment is easiest to catch by comparing the 100% and -100% states.
4. Check strain (optional). Open Advanced Options in the left menu and turn on Strain Visualization to see internal strain as the pattern folds. This helps identify regions where the crease pattern is fighting itself.
5. Export. Choose File > Save Simulation as... and pick FOLD for the crease/simulation data, or STL/OBJ for the folded 3D geometry.

Expected Results and How to Verify

• At 0% the sheet should appear flat; at 100% it should reach its fully folded state. If it doesn't, the pattern likely has inconsistent mountain/valley assignments or geometry the solver can't resolve.
• If the model doesn't move at all, confirm the page finished loading and that your browser has WebGL enabled.
• If an uploaded SVG looks distorted, compare it against a built-in example at the same Fold Percent — the difference usually points to a parsing or scale issue in the file rather than the simulator.

Importing Your Own Crease Patterns

Upload SVG or FOLD files directly in the app, following the site's linked import instructions. Two practical notes:

• SVG path parsing is handled by svgpath and path-data-polyfill, so standard SVG path data is the safest bet.
• Curved folds are supported through the triangulation pre-processing mentioned above, but expect the result to be an approximation of the bend rather than an exact physical model.

If you have a crease pattern that would make a good demo, the site invites submissions to the Examples menu by email (the address is on the author's website).

Exporting: Which Format to Choose

Export captures the folded state of your design, so set Fold Percent to the state you want before saving.

Common Snags

• The model won't fold smoothly. Try intermediate Fold Percent values to see where it stalls; the strain visualization often shows the problem area.
• Negative Fold Percent looks wrong. That's expected behavior — it flips mountain/valley assignments, so a pattern that looks correct at 100% will look inverted at -100%.
• VR mode: The site notes instructions for using the app with a VR headset and hand controllers, but also flags that this mode may now be deprecated. Don't plan a workflow around it without testing first.

Background, If You Want to Go Deeper

The simulator was originally built by Amanda Ghassaei as a final project for Geometric Folding Algorithms, with contributors including Sasaki Kosuke and Erik Demaine. The method is described in Fast, Interactive Origami Simulation using GPU Computation (Ghassaei, Demaine, Gershenfeld, 7OSME), and the solver extends work by Mark Schenk and Simon D. Guest and by Tomohiro Tachi. Source code is available on GitHub.

Origami Simulator accepts crease patterns in SVG and FOLD formats for upload, and it can export results as FOLD, STL, or OBJ. SVG is the practical choice for hand-drawn or vector-edited patterns, while FOLD is better for patterns already described as structured geometry data. Curved crease patterns are also supported: the app pre-processes them with a ruling-aware triangulation method so the bending between creases is simulated realistically.

Upload formats

The site points to a set of instructions for preparing files before upload, so check those before assuming a file will load as-is. A pattern that looks correct on screen can still fail if its paths or crease assignments aren't in the expected form.

Export formats

After simulating, use File > Save Simulation as... to export:

• FOLD — keeps the crease-pattern and simulation data in a structured format, useful for further processing or archiving.
• STL — a mesh format suited to 3D printing or mesh-based tools.
• OBJ — a general 3D model format for use in other modeling or rendering software.

Practical preparation notes

• Start from an example. The Examples menu contains working patterns; comparing your file's structure against one of them is the fastest way to spot a formatting problem.
• Curved creases need clean geometry. Because curved patterns are triangulated before simulation, messy or overlapping curves are more likely to produce distorted bending.
• Check the fold direction. The Fold Percent slider runs from 0% (unfolded) to 100% (fully folded), and -100% folds fully with mountain and valley assignments reversed — a quick way to test whether your crease directions are assigned as intended.
• Inspect strain if the result looks wrong. The Strain Visualization under Advanced Options shows where the simulated sheet is under stress, which often reveals a misassigned crease.

If you have a pattern that would make a good demo, the site invites submissions to the Examples menu by email.

Origami Simulator (origamisimulator.org) is a browser-based WebGL app that simulates how an origami crease pattern folds. Instead of walking you through sequential folding steps, it attempts to fold every crease at once by iteratively solving for small displacements in an initially flat sheet, driven by the forces the creases exert. You can use it to load example patterns, upload your own crease patterns in SVG or FOLD format, scrub through the fold, inspect strain, and export the folded result as FOLD, STL, or OBJ. It suits anyone who wants to preview or test a crease pattern rather than follow a step-by-step diagram.

How the simulation works

The core mechanism is simultaneous, force-based folding. The app starts from a flat sheet and repeatedly solves for small geometric displacements caused by crease forces, so the whole pattern converges toward a folded state rather than being animated crease by crease.

Performance comes from running the simulation methods in parallel in several GPU fragment shaders, written from scratch. The solver extends published work on structural-engineering approaches to origami folding and freeform variations of origami, and it uses ruling-aware triangulation to import curved crease patterns and pre-process them so the bending between creases is simulated realistically.

A practical way to picture it: give it a crease pattern with many folds and the app will try to move all of them toward their target angles at the same time, which is why the motion can look unlike a person folding paper in order.

What you can do with it

• Control the fold amount. Slide the Fold Percent slider to set the degree of folding: 100% is fully folded, 0% is unfolded, and -100% is fully folded with the opposite mountain/valley assignments.
• Inspect the model. Drag to rotate the model and scroll to zoom.
• Load patterns. Open other patterns under the Examples menu.
• Upload your own. Import crease patterns in SVG or FOLD format, following the app's linked instructions.
• Export results. Save FOLD files or 3D models (STL or OBJ) of the folded state via File > Save Simulation as…
• Visualize strain. Use Strain Visualization in the left menu of the Advanced Options to see the internal strain of the origami as it folds.
• Try VR (with caveats). If your computer is connected to a VR headset and hand controllers, the app's instructions describe an interactive virtual reality mode; the site itself notes this may now be deprecated.

A quick workflow

1. Open origamisimulator.org in a browser.
2. Pick a pattern from the Examples menu, or upload your own SVG/FOLD crease pattern following the linked import instructions.
3. Drag the Fold Percent slider between 0% and 100% (or down to -100%) to watch the pattern fold and to flip mountain/valley assignments.
4. Rotate and zoom to inspect the geometry, and open Advanced Options to turn on Strain Visualization if you want to see where the sheet is under strain.
5. When you have the folded state you want, use File > Save Simulation as… to export a FOLD file or an STL/OBJ 3D model.

Things to know before you start

• It is not a step-by-step folding guide. The simulation folds every crease simultaneously, so the intermediate motion may not match how you would physically fold the model.
• Curved creases get special handling. Curved crease patterns are imported and pre-processed with ruling-aware triangulation so the bending between creases looks realistic.
• The project is open and extensible. The code is available on GitHub, and the original author invites interesting crease patterns for the Examples menu.
• VR support may be stale. The site's own note says the VR mode may be deprecated, so treat it as experimental.

The site's page does not list pricing or login requirements, so check the app itself if those details matter for your use.

Origami Simulator's advanced features are Strain Visualization (found under Advanced Options in the left menu, showing internal strain as the pattern folds), VR mode (usable with a computer connected to a VR headset and hand controllers, though the site itself notes this may now be deprecated), and GPU-parallel simulation that runs the solver in fragment shaders for fast performance. The source code is also available on GitHub if you want to inspect or extend it.

Strain Visualization

Strain Visualization is the most reliably available advanced feature. It lives in the left menu under Advanced Options and overlays how much the material is stretching or compressing internally as the crease pattern folds.

• When to use it: checking whether a crease pattern folds cleanly or whether some regions are being forced to deform unrealistically.
• How to read it: pair it with the Fold Percent slider. At 0% the sheet is flat; as you move toward 100% (fully folded) or -100% (fully folded with mountain/valley assignments reversed), watch where strain concentrates.
• Practical check: if strain spikes in a region you expected to stay rigid, the crease layout or fold assignment likely needs adjustment before you export.

VR Mode

The site describes an interactive VR mode for anyone working from a computer connected to a VR headset and hand controllers, with separate instructions linked from the page. However, the page explicitly flags this with a note that it "may be deprecated now."

Treat VR as experimental: try it if you already have the hardware, but don't build a workflow around it. The core rotate/zoom/fold interaction works without VR.

GPU-Accelerated Simulation

The folding solver is not a step-by-step animation. It attempts to fold every crease simultaneously by iteratively solving for small displacements in the geometry of an initially flat sheet, driven by forces exerted by the creases. All simulation methods were written from scratch and execute in parallel across several GPU fragment shaders for speed.

This matters to advanced users because it explains the tool's behavior:

• The result is a physical approximation, not a guaranteed-valid fold sequence.
• Curved crease patterns are imported and pre-processed using ruling-aware triangulation so the bending between creases is simulated realistically.
• The solver extends published work by Schenk and Guest (structural engineering approach) and Tomohiro Tachi (freeform variations), plus the paper Fast, Interactive Origami Simulation using GPU Computation by Ghassaei, Demaine, and Gershenfeld (7OSME).

Source Code and Extensibility

The code is available on GitHub, originally built by Amanda Ghassaei as a final project for Geometric Folding Algorithms, with contributors including Sasaki Kosuke and Erik Demaine. If you want to modify the solver, add import/export behavior, or study the shader implementation, that repository is the entry point. Rendering and 3D interaction rely on three.js, and SVG path parsing uses svgpath and path-data-polyfill.

Choosing What to Use

If your goal is producing a usable folded model, rely on Strain Visualization plus the standard export path (File > Save Simulation as... for FOLD, STL, or OBJ). If your goal is research or tool-building, go to the GitHub code rather than the VR mode.