Designing Structures That Want to Be Printed

A few years ago I was trying to build large delta 3D printers, and the frame kept beating me. Not the electronics, not the motion system, not the firmware. The structure. Once a machine grows past a certain size, the frame stops being background hardware and starts deciding whether the printer is a tool or an experiment that needs constant nursing.

By large I do not mean desktop machines made a little taller for marketing reasons. I needed genuinely useful working volume and enough stiffness to keep print quality under control, without turning every prototype into an expensive machining project. At that scale small alignment errors show up directly in the print, vibration becomes hard to ignore, and the mechanical structure quietly sets the ceiling on everything else.

The answer that finally worked was a spaceframe chassis built from stock tubes and 3D printed joints. The tubes supplied length, straightness, and stiffness, so the printer never had to manufacture bulk material. The printed joints handled the awkward three-dimensional geometry: tube angles, mounting features, clearances, and local interfaces. With a basic tube cutter and a 3D printer, I could build a structure far more precise and serious than the simplicity of the tools suggested.

That changed how I saw additive manufacturing. The printer did not need to print the whole machine. It needed to print the parts where geometry was difficult and relationships were dense: nodes, joints, mounts, and interfaces. Everything else could be bought by the meter.

The phrase I keep coming back to is simple: print the complexity, buy the length.

The Problem With Printing Everything

For a long time, 3D printing was sold as the future of manufacturing, and the promise was not completely wrong. The technology improved dramatically. Machines became faster, cheaper, more reliable, and capable of better materials. Desktop printers became useful engineering tools, and industrial machines became more accessible than they had been only a few years earlier.

The disappointment came from stretching that promise into the idea that we should print complete objects as often as possible. That works beautifully at some scales and for some classes of parts. It works much less well when the object is large, structural, and mostly made of volume that does not need to be complex.

The cube law catches up quickly. If a part is scaled by two in each direction, its volume grows by eight. The printer is then asked to supply eight times as much material, spend far more time in a failure-prone process, manage more heat, deal with more shrinkage and distortion, and keep a larger moving system stable for longer. For high-temperature polymers and metal printing, the build chamber itself quickly becomes one of the main constraints. The machines have improved, but physical scale still pushes back.

This is where many practical people become skeptical. A printed bracket, jig, duct, enclosure, adapter, or custom fixture can be excellent. Those are the kinds of parts where the printer earns its place immediately. But when the same machine is asked to create a large structural object mostly by filling space, the economics and physics become harder to justify.

There is a more useful pattern hiding in plain sight. Use simple stock material where the geometry is simple, and use printed parts where the geometry is hard. Tubes, rods, profiles, plates, sheets, cables, and fasteners are already cheap, accurate, strong, and widely available. A 3D printer does not need to compete with them. It can make the custom connective parts that give those ordinary materials a precise structural relationship.

That is a much more modest claim than "3D printing will replace manufacturing," but it is also a more useful one.

Spaceframes Are Not New

Spaceframes are an old answer to the question of how to make a structure stiff without making it massive. Aircraft, race cars, motorcycles, bicycles, towers, masts, and buildings have all used triangulated frameworks because the underlying logic is sound: put material along load paths, and leave empty space where the material is not doing much work.

The reason spaceframes are not everywhere is not that the idea stopped making sense. The difficult part has usually been the workflow around them. Tubes need to meet at precise angles. Joints need fixtures, welding, brazing, machining, bonding, drilling, or careful measurement. Skilled builders can do this beautifully, but the fabrication process has never been as approachable as the structural principle.

Additive manufacturing changes that tradeoff in a specific way. If the long members stay simple and the complicated nodes are printed, much of the geometric difficulty moves into parts that can be generated, customized, reproduced, and iterated digitally. The printed joint becomes the place where many constraints meet: tube directions, mounting points, cable routing, and assembly logic.

So TrussLab is not based on a new structural principle. It is an attempt to make an old and proven one easier to use in a modern digital fabrication workflow.

How I Arrived There

I did not come to this through historical interest in old aircraft or racing chassis. I came to it through the delta printers. That project became SpaceDelta. The spaceframe printer chassis was not the first concept I tried, but when it finally worked it was difficult to ignore the result. It offered a way to build large, stiff, and precise structures from inexpensive stock material and printed parts, without needing the tooling normally associated with machine frames of that size.

The first versions were still designed in a fairly conventional way. The joints were parametric, which helped, but I was still mostly drawing the parts by hand. Any meaningful change to the structure had consequences throughout the design: tube angles changed, mounting interfaces moved, clearances had to be checked again, and the relationship between the frame topology and the joint geometry was always more tightly coupled than the CAD workflow wanted to admit.

Eventually I started building my own design system. The first useful version was not a visual editor at all. It was a code-driven CAD workflow built around generated OpenSCAD models. I could describe a structure as data, change parameters quickly, generate the geometry, and inspect the result in a modeling window. It was not friendly in a mainstream CAD sense, but it let me work at the level I actually cared about: nodes, links, joints, parameters, and repeated structural patterns.

That workflow led to another substantial project: Spacedrone, a family of ultralight drone frames. The domain was different, but the design idea carried over. A lightweight frame could provide stiffness and packaging space, while generated printed joints encoded the difficult local geometry. The same system also turned out to be useful for smaller practical objects: wall hangers, workshop fixtures, mounts, and one-off structures where the exact shape mattered but the basic principle was the same.

At that point the limitation was no longer whether the method worked. The limitation was that the method was locked inside my private workflow, hidden behind code, scripts, and generated geometry. For people who wanted to design physical structures visually, that was too much friction.

The design system needed an interface, and the broader idea needed a home.

That is why I started building TrussLab, with Frames as its first editor.

What TrussLab Is Trying To Be

TrussLab is a design environment for printable spaceframe structures. Frames is the editor inside it for working with nodes, links, joints, and printable attachments.

The important difference from a general-purpose CAD workflow is that the logical frame stays visible. In a conventional modeler, a frame usually becomes a set of solids: tubes, brackets, sockets, holes, offsets, cut ends, and clearance features. Those solids may represent a spaceframe, but the actual intent is mostly implicit. The CAD file knows the shapes. It does not necessarily know that one element is a logical link, another is a printed attachment, and another is a physical tube that must be shortened because a socket occupies part of the span.

Frames starts from the opposite direction. The user describes the structure as a network first: nodes, links, and relationships. Physical tubes, printed joints, attachments, sockets, and clearances are generated from that description. The final geometry still matters, but it is downstream from a model that understands why the geometry exists.

That makes some annoying parts of physical design much easier to automate. A logical link is a clean idea: connect this point to that point. A physical link has to live in the real world. Its length may need to be adjusted to make room for other links where they meet inside a junction. Its size should also drive regeneration of dependent parametric parts, such as junctions and link attachments.

If the editor knows the difference between the logical frame and the physical members, it can reconcile many of those details instead of forcing the user to manually chase them through the model.

This is one of the reasons the workflow can feel different from ordinary CAD. With a palette of ready-to-use link attachments that auto-adjust based on their parent links, creating a structure becomes closer to assembling a modular construction system. You are still designing, but you are not sculpting every socket and clearance from scratch. You connect meaningful elements, choose how they should physically resolve, and let the editor handle more of the repetitive geometric bookkeeping.

The rest of the editor exists to fix the two problems that actually slowed me down for years. The first was that every meaningful change rippled through the whole design, and there was no safe way to explore. So Frames is built on a transaction model: each action is a reversible, recorded step, which is what makes auto-save and a seamless undo/redo stack trustworthy enough to experiment freely. You can change the structure, watch the dependent geometry regenerate, and back out cleanly if you do not like the result.

The second problem was that the method was impossible to share. I could send people finished models and whitepapers, but not the way of working that produced them. Because every action is a recorded step, Frames can attach a natural-language description to each one and replay the whole construction. An autoplay mode lets someone watch a model being built decision by decision, pause, step in, and take over at any point. The design process itself becomes something you can hand to another person, which is exactly what was locked inside my private workflow before.

TrussLab takes the method that emerged from SpaceDelta, Spacedrone, and many smaller experiments, and makes it usable without asking people to adopt a private code-based CAD workflow.

What This Opens Up

Once printed joints can turn cheap stock material into precise custom structures, the list of things an individual can credibly build gets longer: machine frames, robotics structures, drone frames, furniture experiments, workshop fixtures, and other lightweight custom assemblies. None of these require owning a machine shop. They require a printer, some stock, and a way to design the parts where the geometry is hard.

That last piece is the one that has been missing. The structural principle is old, the materials are cheap, and the printers are good enough. What has not existed is an approachable way to design the connective geometry as a network rather than as a pile of solids.

That is the design space TrussLab is built for: not printing everything, but printing the right things, and letting ordinary people build structures that used to require a workshop.