DEV Community: Asad Waseem

Cura doesn't have connector generation. I built a plugin, and a one-click installer, that does.

Asad Waseem — Sat, 22 Aug 2026 08:23:55 +0000

OrcaSlicer and PrusaSlicer both let you generate mechanical connectors, plugs, dowels, snaps, dovetails, when you split a model for multi-part printing. Cura doesn't, and it doesn't expose an official plugin API you can hook into to add this the right way either. That gap is why cura-connect exists.

How I built it

Two phases, verified at each step rather than assumed to work:

Phase 1: a headless geometry engine, so I could get the actual connector math (plug clearances, dovetail angles, snap-fit tolerances) right in isolation before touching Cura at all.
Phase 2: the real interactive Cura Tool, wired into Cura's UI so you can place and adjust connectors directly on a split model. Verified live against my own Cura 5.13 install, not just unit tests.

The vase mode fix

Connectors were originally sized from the seam's overall bounding box, fine for a solid part, but wrong for a hollow or thin-walled model like a vase. On a real wavy vase test, connectors either landed in empty space or came out chunkier than the wall they were attached to. I fixed it so connectors now size themselves from the model's actual printer profile settings, wall thickness and line width, and test candidate placements against the real geometry instead of guessing from a box.

The installer

I didn't want the only path to be wait for Marketplace approval. So there's now a real cross-platform installer in the repo (installer/install.py, plus double-clickable wrappers for each OS) that finds your Cura installation and drops the plugin into the right, correctly-nested folder automatically. Building it caught a real bug: my first version flattened the plugin into a single folder, but Cura requires a double-nested plugins///plugin.json layout to actually load it. Caught that by testing against my own real Cura install, not by assuming it would work.

Where it stands

The Marketplace submission is still in review, that'll bring true one-click install from inside Cura once it's approved. Until then, the repo installer does the same job.

What's already happening: people in the 3D Printing Pakistan community, printing on Creality and Qalam machines, have started using it and sending back live feedback, which is shaping what I fix and add next.

Repo: https://github.com/rx290/cura-connect

Building an offline CAD tool that can also turn photos into 3D meshes

Asad Waseem — Sun, 16 Aug 2026 16:02:12 +0000

I originally put PolyForge together as a ChatGPT skill, just for OpenSCAD, so I could describe a bracket or an enclosure and get back something I could actually print on my modified Ender 3 V2 or my QALAM Pro 400, instead of hand modeling every mount and shelf myself. It worked fine, but it only worked in ChatGPT, and it needed an agent and an API bill in the loop even for a plain shelf bracket. That felt backwards. A shelf doesn't need a language model to exist.

So I pulled it apart and rebuilt it as PolyForge, a standalone Python package. No agent, no LLM required for the core. It runs the same whether you point Claude Code, ChatGPT, Gemini, or a local model at it, because the actual capability lives in the package itself, not in something only one vendor's assistant knows how to run.

What it does today

A small library of parametric part templates (box, wall shelf, corner bracket, cable comb, standoff mount) gets filled in from plain text by keyword matching and regex extraction, then rendered to any of three CAD backends: OpenSCAD, FreeCAD, or Blender. All three produce the same geometry, dimension for dimension, for the same template and parameters, and every template is compile tested against the real binaries, not just unit tests.

This week I added a fourth capability: offline photogrammetry. polyforge reconstruct-from-photos takes a directory of overlapping photos of a real object and turns them into an STL, entirely offline, no cloud API involved.

The COLMAP discovery

The pipeline runs COLMAP for structure from motion. COLMAP also has its own dense reconstruction stage, the part that would normally take a sparse point cloud and turn it into something dense enough to mesh. I assumed it might need a GPU, but I didn't want to assume, so I ran it without one on purpose and watched what happened.

It aborted immediately: "Dense stereo reconstruction requires CUDA, which is not available on your system." No CPU fallback anywhere in the mainline binary. That single test changed the whole architecture. Instead of one tool doing everything, the pipeline now uses COLMAP only for its CPU capable sparse reconstruction, then hands the result to OpenMVS, whose densify and mesh stages build CPU only by default, for the part COLMAP itself can't do without a GPU.

Three patches to build OpenMVS

Getting OpenMVS running on a rolling release system with a newer OpenCV than the package expected took three separate source patches. Its pinned vcpkg commit had a data schema too old for the installed vcpkg binary. Two OpenCV template specializations it defined itself collided with ones OpenCV now provides natively. And one constant, cv::DIST_L1, had been removed from OpenCV's imgproc module entirely, so I inlined the literal value at the one call site that needed it. None of this is really about PolyForge, it's just what building against a system that moves faster than an AUR package's last update looks like in practice.

What actually breaks a reconstruction

Once the pipeline worked, I wanted to know where its real limits were, not the ones I assumed. So I ran an extensive test matrix: different photo counts, different camera coverage patterns, a more geometrically complex part, and timed every stage.

The biggest finding surprised me. I expected photo count to matter most. It doesn't. A camera orbit at a single elevation fails outright no matter how many photos you take, even 24 of them. You need at least three elevation rings. Once you have that, thirty photos across three rings reconstructed cleanly, twenty seven did not.

The second finding was about where the time actually goes. I assumed the matching stage, which compares every pair of photos, would be the bottleneck as photo count grew. It barely moved. The real cost is COLMAP's incremental bundle adjustment: about three seconds at sixteen photos, over two minutes at thirty six, a much steeper jump than the photo count alone would suggest. And it scales with the object's geometric complexity too, not just the count. A bracket with concave, non convex features took six times longer than a plain box at the same photo count, even though both reconstructed correctly in the end.

Where it stands

Four phases in, PolyForge can generate parts from text across three CAD backends and reconstruct a mesh from a folder of photos, all without a cloud API or a GPU. The reconstructed mesh is not perfect: it has no absolute scale until you measure something known on the real object and rescale it, and it usually isn't watertight since a camera orbit can't see a surface's underside. Both of those are honest limitations of photogrammetry itself, not bugs, and I'd rather say so plainly than pretend otherwise.

Repo's public if you want to look at the actual code: github.com/rx290/polyforge

How I built a Claude Code skill that finds funded scholarships without burning your token budget

Asad Waseem — Wed, 12 Aug 2026 11:49:02 +0000

I went looking for something that could find fully-funded PhD and Master's programs in Europe, matched to my own grades and field. What I found on GitHub was three small, disconnected projects, and none of them actually worked for what I needed.

One only covers professors in the US, UK, Canada, and Australia. Another needs its own separate paid LLM API key and a Feishu account just to rank a list. A third has no idea what a funding scheme even is, and none of them cover anything below a PhD, even though there's just as much scholarship money for undergrads.

So I read through all three, kept the ideas that were actually useful, and rebuilt the rest from scratch.

What it does

GrantCompass is a Claude Code skill plus a standalone CLI. Point it at a field and a grade, and it finds:

Fully-funded scholarships and programs at any degree level (Bachelor's, Master's, PhD), any country, defaulting to Europe if you don't name one
Professors doing relevant research if you're applying to a Master's or PhD, pulled from OpenReview and OpenAlex, both free public APIs
A score for each result: whether your grade comfortably meets what a scheme typically expects, is borderline, or falls below it. It never silently drops a result over that, you make the call.

The part I actually care about

Most of these tools work by scraping a bunch of web pages and dumping the results into an LLM's context. That's slow and it burns a lot of tokens for something that's mostly just fetching and filtering, work a model doesn't need to do.

So the fetching, parsing, and scoring here all happen in plain Python behind the CLI. The agent only steps in for two things: asking a couple of onboarding questions, and pulling current listings from sites that don't have a stable API. Even then, it reads back exactly one compact table, not the raw pages it fetched.

grantcompass init
grantcompass professors
grantcompass score
grantcompass report
cat output/report.md

Why not just scrape DAAD or FindAPhD directly

None of them expose a real public API, and scraping risks breaking their terms of service, plus it breaks the moment they redesign the page. That's basically what happened to the projects I looked at before building this. The only script here that makes its own HTTP calls is the one doing professor discovery, and it only talks to OpenReview and OpenAlex, both built for this kind of programmatic access. Everything else gets fetched live, one page at a time, by Claude's own web search, closer to how a person would actually go look it up.

Credits

No code came from the two prior-art repos with no license attached, only the ideas did. Full writeup on that, and everything else, is in the README.

Repo: https://github.com/rx290/grant-compass

If you're also hunting for funded programs, or just curious how a token-conscious Claude Code skill is put together, take a look. Feedback and PRs welcome.