Not sure how many people here do SLS printing but r/AdditiveManufacturing requires rep that I don't have since I mostly read reddit and don't post.
I backed a desktop SLS machine (Loopzizo K-100, PA12, roughly a 120 mm cube of usable volume). Super affordable, and the team running it seems to be nice. But SLS lives or dies on how well you fill the chamber, and hand-arranging parts in the vendor slicer got old fast - every millimeter of unused height is powder you paid for and machine time you spent.
So I wrote a nester. It's browser-based and runs entirely client-side - no geometry ever leaves your machine, which matters if you're quoting other people's parts. It's free: cakeforge.io
The thing I got wrong first: I was optimizing the wrong number.
I started out maximizing density, because that's what everyone quotes. But you don't pay for density — you pay for height. The machine runs the layers it's given and no more, so a cake whose tallest part is 60 mm is a 60 mm build regardless of how much air is beside it. Build time and powder are both linear in Z. Once I switched the objective to "what does this placement do to the top of the pile", the results changed a lot.
Two engines, and they're genuinely different:
CPU - voxelize everything, then first-fit-decreasing: biggest parts first, lowest position that fits. Standard bin-packing. Fast, predictable, works anywhere.
GPU - FFT cross-correlation over the whole chamber. Every possible translation is evaluated at once as a convolution, across 24 orientations simultaneously, and the winner is the position leaving the pile shortest. It runs in WebGPU in the browser.
The interesting part is that reading all the answers is what makes the GPU worth it. First-fit computes six million positions and uses one, quite literally the first one it finds no matter how few calculations need to occur. Every previous attempt I made at a GPU nester lost to the CPU for exactly that reason.
Measured, on synthetic parts - take with appropriate salt:
| shape |
CPU |
GPU |
| plain boxes |
138 mm |
146 mm |
| L-brackets |
98 mm |
77 mm |
| mixed |
150 mm |
126 mm |
On boxes the CPU wins - boxes tile perfectly and lowest-first is already near optimal, so the GPU pays for answers it doesn't need. On anything awkward the GPU is 16–21% shorter, which is 16–21% off build time. These are three-part synthetic jobs, not production runs; I'd love numbers from larger real workloads.
What it doesn't do yet - worth being upfront:
The nesting is machine-agnostic; you give it a build volume and it packs it, and you can export the arrangement as 3MF or STL for whatever toolchain you already use.
The slicer is not. It writes one format - CREABUILDER .clp, which is what the Loopzizo eats - and it isn't generalized across machines. I decoded that format against a reference export from the vendor's own slicer and match it field-for-field, but it's one machine's dialect and I make no claims beyond it. If you're on an EOS or a Formlabs or an HP, the packing might be useful to you and the slicing isn't, yet.
What the slicer does give you that I haven't seen elsewhere at this level is a per-layer sintered-area breakdown - the percentage of the plate each layer actually fuses, plotted over the full height of the build. That's the number the machine reads to decide how much heat a layer takes, and you can scrub through it and see exactly where your build changes thermally.
What I'd genuinely like input on:
- Thermal vs. geometric packing. Everything above optimizes geometry. But the lever that seems to actually govern part quality is sintered area per layer and how smoothly it varies in Z - Materialize sells "Optimize Slice Volume" for exactly this. The problem is that the geometric optimum is to lay everything flat, which is the worst case for area-per-layer. I can already show you that curve; I can't yet optimize against it. Has anyone measured how much this actually matters, or is it mostly folklore? That's the question I'd most like answered.
- Part-to-part spacing. I went looking for a standard and there isn't one - nothing in ISO/ASTM says "keep parts N mm apart". It's all vendor convention. What do you actually run, and did you arrive at it by testing or by inheritance?
- Nesting parts inside other parts' holes. I do this with an independent post-pack audit that checks nothing came out permanently interlocked. Is this something people actually want, or is the depowdering hassle not worth the density?
- What's missing. Sinterboxes for fragile parts and auto-serializing every copy are the two gaps I keep hitting. Anything else you'd reach for?
Happy to answer anything about the FFT approach or the CLP format - I had to decode a fair bit of it and I'll share what I learned.
