r/3DPrintingTools

I’ve been working on a CAM/CAD app for a while now, mostly because every tool I used kept slowing me down or forcing me into workflows that made no sense. So I finally snapped and built my own.

The whole thing is real‑time. You move geometry, it updates instantly. No sketch modes, no “finish sketch,” no regenerating half the model because you changed one dimension. It feels way closer to actually shaping something instead of babysitting a CAD program.

On the CAM side, I added a bunch of logic that helps instead of getting in the way. It suggests toolpaths, predicts collisions, auto‑builds roughing/finishing passes, and points out weak geometry before you commit to anything. It’s not “AI magic,” it’s just smart enough to stop you from doing dumb stuff or wasting time.

Everything updates live. Change the model → toolpaths update. Change the toolpath → simulation updates. No rebuild buttons, no dependency chains exploding because you nudged a face.

Performance was a big focus too. Geometry, slicing, material removal — all of it is GPU‑accelerated and reacts instantly. It’s the first CAM/CAD setup I’ve used that doesn’t break my flow.

If anyone wants to see it, I can post videos or GIFs. It’s way easier to show than explain. And if you’re into machining, CNC, CAD, robotics, whatever — I’d actually love feedback. I’m trying to make something that feels modern instead of stuck in 2005.

If you want to try a demo build, just say so.`

Hi everyone,

We've been building LocalMesh for the past few weeks, and the beta just opened.

Short version: one photo goes in, and you get a 3D Gaussian splat (~60s on a 5090, ~2min on a 4060 laptop), then a textured mesh** (UV-unwrapped, photo reprojected, AO, normal map) exported as GLB/PLY/OBJ.

Everything runs locally. No upload, no queue, no credits. Turn off your Wi-Fi, it still works.

The mesh part is the bit we're proud of. Poisson reconstruction on gaussian centers drapes a tarp over your object: a Poisson solver has to close every surface, and can never say "I can see through here".

So instead: 60 virtual cameras on a golden-angle sphere, gsplat renders depth for each, every ray carves out the empty space it travels through, and the 60 depth maps fuse into a 768³ TSDF volume. Carving instead of guessing. (gs2mesh principle, written from scratch.)

Other things you might enjoy:

- It runs on 8 GB cards. The entire conversion (splat rendering, TSDF fusion, decimation, atlas bake) stays under 7.3 GB of VRAM, so a 4060 laptop finishes the exact same job as a 5090, just slower.

- No CUDA toolkit, no Visual Studio, no Python, no admin rights on the client. We ship a fat gsplat wheel with precompiled kernels, RTX 20 to 50.

Limits, upfront: one photo means the back of the object is invented, not measured. Windows + NVIDIA 8 GB only. No Authenticode cert yet, so SmartScreen will grumble on first launch.

7 days free, no card to start, then $39 once, no subscription, because there's no cloud to pay for: https://local-mesh.com

Break it and tell us, that's what the beta is for.

Happy to answer anything about the pipeline in the comments.

Hey everyone,

I was working on organizing my workshop drawers and realized how tedious it was to manually model, adjust tolerances, and export individual bins in CAD just to fit my specific drawer dimensions.

To solve this, I built a free web app that lets you design custom drawer layouts in seconds without needing CAD software.

Key features:

• 2D/3D Live Canvas: Input your drawer dimensions and build your layout visually.
• Printer Bed Boundary Validation: Set your build plate size (e.g., 220mm) — the tool highlights oversized boxes in red and blocks export until everything fits your bed.
• Custom Divisoras & Heights: Adjust wall/bottom thickness, corner radius, box height, and add vertical or horizontal dividers.
• Instant STL Export: Export ready-to-print STLs (automatically recentered to origin for clean slicer importing).

It’s completely free to use directly in the browser. I’d love to hear your feedback, feature requests, or suggestions on what to add next!

I’ve been working on a small free project called FlashFit AI, mainly for the Flashforge Adventurer 5M.

I started it because I was tired of changing many slicer settings every time depends from the model, filament and quality I wanted. The idea is simple: you load an STL, OBJ or 3MF file, choose the material and quality, and the app analyzes the geometry before preparing settings for that specific model.

It checks things like dimensions, overhangs, small details, separate parts and proportions. Then it adjusts speed, acceleration, walls, infill, supports, cooling and adhesion.

I honestly don’t know yet how useful it will be for everyone, but it works pretty good in my tests, so I decided to share it and maybe it can help other Adventurer 5M users too.

The macOS Apple Silicon version is currently the most complete and polished one.

The Windows 11 version is still in alpha. It works, but the interface and some parts are still rough and I’m actively improving it.

For now it supports the Adventurer 5M with a 0.4 mm nozzle. In future I want to add support also for other Flashforge printers and later printers from other brands.

It’s free at the moment and I would really appreciate honest feedback, test results or suggestions. Please always check the generated project and slicing preview in Flash Studio before printing, because the project is still young and there can be some problems.

GitHub and downloads:

https://github.com/alexmark53343-byte/FlashFit-AI

Every time I needed a STEP turned into an STL, or any other conversion, I ended up on some converter site that wants an email address and keeps your file on their server for a day. So I built one with no server at all.

It's OpenCascade compiled to WASM running in the tab. Drop a file, look at it (shaded / wireframe / edges / x-ray, per-part visibility for assemblies), convert it. 34 formats read, 16 written, every combination works. The options that actually decide whether the output is usable are all exposed: binary vs ASCII, output units, Z-up vs Y-up, tessellation quality, recentre, weld, flip normals. Drop several files at once and you get a ZIP back.

No backend, no account, no size limit, no upload. The page is served with `default-src 'self'` and no external connect-src, so it can't phone home even if I wanted it to. Works offline once loaded.

There's a Benchy on the landing page if you want to poke at it without hunting for a file: cadverter.net

Free, no ads. If a file in your workflow breaks it, tell me and I'll fix it — that's most of why I'm posting.

Hey all

I've been building this for the past year and just released it on Package Manager and food4rhino: Slicelab Tools. It's a GH plugin for Rhino 8. It's free, open source (AGPL), and runs on both macOS (Apple Silicon native) and Windows.

It started because I do a lot of 3D printing work and kept hitting the same walls: no good way to generate tetrahedral lattices without leaving Grasshopper or only on Windows with very limited tools, and no PDF layout at all on Mac. So I built the tools I wanted:

• Tetrahedralize + 10 lattice generators: turn any closed mesh into tetrahedra, then swap between 10 lattice topologies (vertex/midpoint/face-center networks, edge lattices, Voronoi dual). Pipe the struts into Dendro for a printable volume.
• Adaptive TriRemesh: triangular remesh with feature curves/points embedded in the output topology + attractor-driven density
• Mesh Operations: Manifold mesh booleans, plus repair/refine/decimate nodes
• PDF layout: composable multi-page documents (nothing fancy) straight from GH (text, images, Make2D linework, viewport captures). Mac users: this one's for you.
• Export: fast binary STL, 3MF with metadata, GLB with Draco compression

Install: Rhino 8 Package Manager → search SlicelabTools. (Windows: Rhino needs the NETCore runtime — run SetDotNetRuntime, pick NETCore, restart.)

Docs with every component: tools.slicelab.com
Source: github.com/slicelab/Slicelab-Tools

I'm the author, happy to answer anything. If you try it and something breaks, please let me know, this is one of the main reasons for posting it here.

Thanks

Open-source 3D scanning just got a level-up

I am still working on the 3d printed macro add-on for the OpenScan Mini & Classic (that might also be used in combination with a smartphone!). Therefore i am currently re-visiting some old scan object that I digitized years ago and the improved quality is stunning.

I already published an initial version of the printable files on our discord, but more details and a build-guide will follow soon.

PSA: never leave your keys unattended ;)

(Disclosure: I am the solo developer behind the app mentioned below, stl-er)

Yesterday, Gemini 3.7 Flash came out, and I immediately started testing it under the hood of my app, stl-er. After doing some prompt engineering, I am honestly blown away by the results.

The biggest highlight? I tested the new model's vision capabilities by uploading 2D drawings, one professional 2D drawing (not attached due to NDA) and two of my own hand-drawn sketches (see attached images and the resulting screenshots).

The interpretation was mind-blowing: 3 uploads, 100% correctness. It provided totally correct models in about 30 seconds each, and even mapped out all the relevant parameters for me to tweak afterward. It’s crazy.

Why this matters for 3D printing: Before this, I had tested almost every model up to Fable 5. Most of them heavily struggled with spatial understanding. Plus, earlier models like GPT 5.4 mini or Gemini 3.6 Flash were just too slow to run any kind of "medium thinking mode" without creating a terrible, laggy user experience.

It’s always a battle between speed, quality, and cost, but Gemini 3.7 Flash finally hits the sweet spot. It’s so fast that medium thinking mode is now perfectly viable. I did test some highly complex parts and eventually hit the model's limitations, but the ceiling has been raised significantly. The future of these models is going to be insane.

A bit about stl-er and why it's not just another AI mesh generator: My vision for stl-er was always to build a bridge from an idea to a print-ready model for people who just don't want to learn complex CAD. Under the hood, the app uses OpenSCAD to generate real CSG. Because we aren't just throwing together messy AI meshes, the app is built specifically for functional parts. It’s not meant for printing figurines or organic statues. We want parametric, watertight models for real-world parts.

• One of the biggest values of the app is the community aspect:
• All generated models go into a public community library.
• Anybody can pick a model, adjust the parameters, download it, and print it.
• Zero licensing restrictions. Do whatever you want with the files.
• It is totally free to browse the library and download up to 5 models per month (and absolutely no ad mobs).

One quick heads-up on logging in: Currently, you can only log in with Apple or Google. I know not everyone loves OAuth, but I actually had to remove the standard Email/Password login because bots started aggressively scraping the model library before the app was even officially released. Once I figure out a bulletproof way to verify emails, I'll bring it back.

I'm incredibly excited about where this is heading and glad we are on the right track. If you want to mess around with it, you can find more info and the App Store / Play Store links over at
stl-er.com

Every image-to-SVG converter advertises "100% accuracy," and none of them define it. I built one that actually measures it.

Vecline renders its own SVG output back to pixels with the same renderer a browser uses, and scores it against the source with SSIM, PSNR and CIEDE2000. The number you see is measured from the real output, not estimated from the settings.

What that buys you:

- On flat artwork (logos, icons, UI, screenshots, pixel art) it's bit-exact: the SVG rasterizes back to the source with zero differing pixels, in a smaller/faster file than potrace, imagetracerjs or vtracer. You can reproduce the head-to-head yourself with `npm run compare`.

- On photographs, tracing is approximation by definition, so it says so and reports how close it landed instead of claiming perfection.

- A `--lossless` mode that returns a byte-verifiable SVG or fails, never a silent near-miss.

- Cut-ready DXF with a real physical size (`--units mm --physical-width 80`) plus EPS/PDF/G-code, for the maker/CAD/laser crowd.

- PDF and Office rendering, all local.

- A zero-dependency portable core that's CI-proven to bundle for a browser at 85 KB, and an MCP server so an agent can vectorize and verify its own output.

MIT, no signup, nothing uploaded. There's a browser app that runs entirely client-side.

The part I'm most happy with is boring: because the tool measures itself, it also catches me. It has flagged three of my own README overclaims (a benchmark that was true against a wrapper but not vtracer's real binary; a "render-preserving" label that was actually a ~0.02 SSIM trade; a `convert` command that couldn't do 100 of the 121 conversions the docs advertised) and I fixed each in public. For a project whose whole pitch is "measured, not asserted," being adversarial toward its own claims is the actual feature.

Repo: https://github.com/shunyagatha/Vecline

Try it: https://vecline.xyz

npm: `npm install vecline`

Happy to answer anything about the measurement approach, the tracing internals, or where it loses (it is genuinely worse than vtracer on file size for some photos, which the README now says).

Check it out on maker’s world :)

[Gear Generator](https://makerworld.com/models/3143184?appSharePlatform=copy)

Flairing this properly, it is a paid add-on I made.

It started because of the two chores I hated most before a big resin print: cutting a model down to something that fits the vat, and hollowing it without ending up with a wall that is not the thickness I asked for.

What it does that is resin-specific:

• Hollow takes a wall thickness in real millimetres and gives you that wall, even when the object still carries a scale factor. I measured 19.98 mm on a 20 mm request at four different object scales
• Drain holes either automatically through the lowest wall of every part, or you click exactly where each one goes, under an arm or behind a head, where the cleanup will not show
• Cutting into vat-sized blocks, or a freehand seam you draw yourself so it hides in a fold instead of running across a face
• Every cut face gets a keyed pin and a matching socket, one corner cut off so a part cannot be glued in rotated, plus an engraved 1A / 1B pair, so a 20-part model still assembles without a guessing game
• Mesh check before you export, then STL, OBJ or 3MF in millimetres

Straight answer on the weak spot: a very thin shell cut into large blocks can produce open fragments at thin points. The built-in check tells you which parts, and a thicker wall or a smaller block fixes it. I would rather say that here than have someone find it out at 2 a.m.

Blender 4.2 and newer.

3-minute demo: https://youtu.be/nQitmn3UYoY

Have a look if it is useful to you: https://superhivemarket.com/products/3d-slicer-suite-

Questions welcome, I wrote it.

I work in 3D education and I’m constantly needing to quickly price up prints or work out quotes.

I wanted something I could just bookmark, chuck the details into, get a sensible price, and move on.

Most calculators I found either had paywalls, subscriptions, or locked saved profiles behind an account, so I made my own:

https://printprice.site/

It’s browser based, saves printer and material profiles locally, and the whole point is for the useful stuff to stay free.

I’m not a full time dev, I just made it because I needed it myself and thought other people here might find it handy.

Would genuinely appreciate any feedback, especially from people who price prints regularly.

Want to learn CAD, 3D printing, and engineering?

A few of us high-school students have been building SparqCAD, a free STEM learning platform designed to help students and aspiring engineers learn the actual CAD and engineering skills that can be used in industry-level projects.

You can learn things like:

- CAD & 3D design

- 3D printing

- Engineering & design

- Hands-on prototyping

- Engineering fundamentals

We're still actively developing the platform, and we'd love for other students, makers, engineers, and STEM enthusiasts to join, explore the courses, and give us feedback.

Right now, we have two introductory CAD courses covering Tinkercad and Onshape, two beginner-friendly tools for computer-aided design. We’re hoping to expand into more CAD software, 3D printing, engineering, and hands-on projects as the platform grows. We’d especially love to hear about what skills and topics you think we should add next.

I decided to share SparqCAD here on the E-NABLE forum because I thought the best way to grow the platform is to involve like-minded people who can explore what we’re building and share their ideas.

Even if you don't have time to take a course right now, we'd really appreciate it if you could make an account and take a quick look around SparqCAD. We're just getting started, and we'd love feedback from people actually involved in hands-on STEM, engineering, CAD, and making.

Even just exploring the platform, pointing out things that could be improved, or telling us what you'd want to see in future courses would mean a lot to us.

And hey, if you happen to help two high schoolers build something useful for the STEM community along the way... that's a pretty nice bonus for the college apps :D

Check it out:

https://sparqcad.org

If you take a look, let us know what you think, what works, what doesn't, what you'd like to learn, and what you think we should build next!

I haven't had the time to really sit down and learn 3D modeling yet. I print stuff other people designed, and every once in a while I hit the same wall: a part is close to what I need but not quite — usually a bit too short or too long somewhere — and I only have the STL, not the original CAD file. Scaling the whole thing isn't really an option, it stretches everything and round holes turn oval.

Since I hadn't gotten around to learning the proper way to do this, I put together a small tool that just does the one thing I needed at the time: pick a plane through the part, and insert or remove a slice of material there. Everything else in the mesh — holes, walls, rounded edges — stays untouched, since it's not scaling anything, just cutting and splicing material in or out at that one plane.

SkipCAD, if anyone wants to try it. It's a rough prototype, put together to solve my own specific problem, so I'm sure it breaks on STLs I haven't run into yet. If you've got a part that needs this kind of tweak, I'd like to know if it actually works for you or where it falls over. Contact link's in the sidebar.

Edit: renamed to SkipCAD (unrelated naming collision with an existing filament brand — sorry to anyone who hit a dead link because of it, should be fixed now: skipcad.com). Also shipped a couple of things people flagged here — typing decimal values into the length field actually works now, and you can chain multiple cuts without re-exporting/re-importing the file each time. Thanks for the feedback so far, keep it coming.

Edit 2: Didn't expect the amount of feedback on my last post — genuinely appreciate everyone who tried it, reported bugs, or just left a comment. One request came up a few times, so I built it.

Cutting behind an overhang on a C-shaped part (or a leg of a U-shaped bracket) and only extending/shortening one side, without dragging the rest of the piece along with it.

The short version of why this was hard: normally the tool cuts a piece with a flat plane and moves everything on one side of it together, as a solid block. If the two arms of a C or the two legs of a U don't actually touch at the cut, moving "everything" means dragging both together — not what you want.

What changed: it now checks whether the cut plane is going through a spot where the piece is already physically split into separate pieces. If it is, it highlights each part and you can click to leave one alone — only the parts still selected get extended or shortened.