pleat 0.1.0

Constructing geometric tilings and transforming them into origami crease patterns

Pleat

Construct geometric tilings, and turn them into origami tessellations.

Pleat is a Python library for constructing, manipulating, and visualizing geometric tilings across Euclidean, hyperbolic, and spherical geometries. It can generate crease patterns for origami tessellations and corrugations using several algorithms which can be exported for printing or plotting, and can preview folded states.

Features

• Half-edge data structure — efficient DCEL representation for planar graphs with topology, angles, and positions
• Tiling construction — all 11 Archimedean tilings, Platonic solids, hyperbolic tilings, and custom prototiles
• Conway operators — dual, ambo, truncate, kis, join, gyro, starify, and more (including alternating flagstones, loft, lace, expand, chamfer)
• Three geometries — Euclidean plane, Poincaré disk model (hyperbolic), spherical
• Origami pipelines — shrink-rotate, intersecting cylinders, alternating flagstones
• Folding simulation — flat folding, finding a face ordering by solving an ILP
• Multiple renderers — Cairo for pretty pictures, svgwrite for optimized output for cutting plotters (or laser cutters)

Installation

pip install pleat

To run the example notebooks locally, clone and install with all extras:

git clone https://github.com/imagirom/pleat.git && cd pleat
uv venv --python 3.14
uv pip install -e ".[all]"
jupyter lab docs/notebooks

Finer-grained extras (e.g. to skip heavy dependencies such as torch) are listed in the installation guide.

Quick start

The whole pipeline — build a tiling, turn it into a crease pattern, preview the folded state:

import numpy as np
import pleat
from pleat.shrink_rotate import crease_orientation, shrink_rotate_pattern

# build a tiling: two rings of hexagons around a central one
G = pleat.example_graphs.from_tiles(pleat.example_tilesets.platonic(n=6), rings=2)

# decide which faces fold on top, then construct the crease pattern
crease_orientation.assign_this_way_from_center(G)
CP = shrink_rotate_pattern(G, simplify_boundary=True, alpha=np.pi / 5, factor=0.5)

# fold it: preview the folded state with solved layer ordering
pleat.overlap.fold_complete(CP, quiet=True).show()

Documentation

The full documentation lives at imagirom.github.io/pleat. Its heart is a series of executed Jupyter notebooks — starting with the pipeline overview — covering tiling construction, and methods to turn them into origami tesselations. The notebook sources are in docs/notebooks/.

To build the site locally:

uv pip install -e ".[docs]"
mkdocs serve                      # dev server at http://127.0.0.1:8000

Development

uv venv --python 3.14 && uv pip install -e ".[dev]"   # contributor setup (in a clone)
uv run pytest -m "not slow"                    # tests (drop the -m flag for the full suite)
uv run --extra dev black --check pleat tests   # formatting check
pre-commit install                             # install git hooks

GitHub Actions CI runs tests, lint, and mkdocs build --strict on every push and pull request (.github/workflows/ci.yml).

License

The code is MIT-licensed — see LICENSE.

The photographs of folded origami models (in docs/notebooks/images/) are © Roman Remme and licensed under CC BY-NC-ND 4.0.