PD - Polyhedra

Loading - please wait...

- Settings Files
- Browser Storage
- Final Polyhedron Data
- Example Shapes
- Example Frames
- Copy to Clipboard

Operations are executed in left to right order.

Editable Modifiers

a: ambo()
b: bevel(sides, offset)
c: chamfer(detail, distance)
d: dual()
e: expand()
f: frame(inset, thickness)
g: gyro()
h: hollow(inset, thickness)
i: inflate(degree)
j: join()
k: triakis(sides, outset)
l: loft(sides, inset)
m: meta(sides, outset)
n: insetN(sides, inset, outset)
o: ortho()
p: propellor()
q: quinto()
r: reflect(axis)
s: snub()
t: truncate(sides, offset)
u: trisub(divisions)
w: whirl()
x: extrudeN(sides, outset)
z: triangulate(sides+)
- - - - - - - - - - - - - - - -
A: adjustXYZ(iterations),
C: canonicalize(iterations),
F: triangularFan(sides, outset)
J: jitter(seed, radial, spatial)
N: noise(amplitude, scale, offset)
P: stellation()
U: unitRadius(radius)
V: unitSize(size)
W: wrinkle(seed, radial, spatial)
- - - - - - - - - - - - - - - -
R: rotate(rx, ry, rz)
S: scale(sx, sy, sz)
T: translate(dx, dy, dz)
- - - - - - - - - - - - - - - -
/: ± ignore

Name: {{ polyhedraInfo.name }}

Faces: {{ polyhedraInfo.faceCount.toLocaleString() }}

Edges: {{ polyhedraInfo.edgeCount.toLocaleString() }}

Vertices: {{ polyhedraInfo.vertexCount.toLocaleString() }}

{{ polyhedraInfo.size }}

© AndrewMarsh.com

This web app puts the creative and expressive power of Conway polyhedron notation at your fingertips. The aim is to choose some relatively simple seed geometry and apply mathematical modifiers to generate more complex geometry.

In this way, it can be used to generate a range of topologically rich and potentially useful sculptural forms, to explore the potential of mathematical shape manipulation, or to enrich your own understanding of different types of polyhedra and the modifications available.

I have tried to include all of the standard Conway operations - borrowing heavily from some of the techniques used by Anselm Levskaya in polyHédronisme, as well as George Hart's Polyhedron Generator and David McCooey's Visual Polyhedra – plus several of my own that I have developed and used over the years.

I have also tried to offer a range of ways to get shape data into and out of the app. You can import or directly edit base shape geometry using the Edit Base Shape... dialog box, and export the final shape using the Export Final Geometry... dialog (which supports .GLTF, .GLB, .USDZ, .3DM, .3MF, .OBJ, .STL and .PLY).

Once you have selected the base polyhedron you want to use, either enter a notation string directly in the 'Conway Notation' input box or build one up by adding and editing operations in the editable stack.

When just starting out, the quickest way to experiment is to just start typing modifier characters in the input box. As you develop your shape, the notation strings can sometimes get quite long, especially when using bracketed arguments. The notation string itself is the fundamental 'source of truth' in terms of shape modification, so you can switch back and forth between the modifier list and editable stack at any time to make working with it a bit easier.

The stack provides a dynamic list of editable modifiers that you can drag to reorder, or click on to access editors for each of the parameters that the different operations use. When you edit the modifier stack, it will update the notation input string. However, if you modify the notation input string, it will rebuild the modifier stack.

The following are some of this app's features and idiosyncrasies:

This app can handle higher-order polyhedra with many hundreds of thousand vertices and a similar number of faces. However, anything above about 400k will likely test your patience when editing it, so best to edit a simplified base and then add smoothing expansions only when you want to export or visualise.
Some of the modifiers used by Levskaya and Hart assume that the base shape closely approximates a sphere of unit radius centered at the origin, and modify vertices accordingly. To make this work, a lot of their modifiers rescale the shape to a unit radius on each step. Doing this makes it almost impossible for the modified shape to maintain progressive dimensionality, and adds a lot of computational overhead.

As a result, I have removed these assumptions from most of the modifiers (in some it's kind of fundamental to how they work) and added a U modifier to rescale the shape to a unit radius that you can add as you need. I have also added a V modifier that rescales the shape to exactly fit within a 1x1x1 box based on its extents.
I have tried to provide a range of different facet colouring options based on relative area, number of edges, face orientation, and a combination of all three to create a signature for like faces. Different types of polyhedra will look good with some and not others, so you will need to experiment for best results.

You do not need to know anything about Conway polyhedron notation to have fun with this app. You can just experiment by trying out different operators one by one to see what they do. Moreover, you can choose any of the examples and then start enabling or disabling individual modifiers to see the effect they have, or editing their parameters to investigate.

Another useful way to experiment is to turn on the base shape overlay and see the effects of just a single modifier on the final shape. I use that a lot in my testing.

If you do want to know more of the theory behind the notation, the best reference is the Wikipedia page linked to above, as well as George Hart's original explanations.

This is the third iteration of my polyhedron generator tool. The first one was a Java applet using Processing back in 2012. The second one from 2019 was a web-based tool using Javascript and WebGL, based on Knockout.js and my own graphics framework. This one from 2025 is also JavaScript and WebGL, but based on Vue and THREE.JS.

One of the core aims of the broader framework I am developing is to enable building performance analysis and simulation on amorphous and curvilinear forms just as easily as on planar and rectilinear shapes. When working on new geometric forms and stress testing my closed-shell geometry class, I have been using this app a lot as a kind of visual test suite. Thus, I have added to and extended it quite a bit over the years to let me do all the things I need.

Also, this app is relatively simple compared to my other BIM tools, so I have used it (and a couple of others) as a test bed for migrating to the latest versions of Vue, Bootstrap and THREE.JS, before bringing changes over to my core tools. I have also used it to test the import and export functionality of basic geometry formats.

Finally, I can't tell you the number of times that I have been debugging something and, simply by being able to see how the geometry changes compared to the base shape, have had some fundamental insight that has really helped me understand what I was actually doing. Thus, I figured it may be similarly useful and insightful for others so would make a good candidate for the first of my new web tools to be released in 2025 using my new framework.

© Dr. Andrew J. Marsh, 2012-2025.