Today gave us two real wins.

First: wheels can have custom cuts now. I started with a traditional pattern, partly because it gives a clean reference point. If you are going to change geometry, it helps to begin with something watchmakers already understand.

The point is not decoration for its own sake. The point is control. Once the process is stable, we can explore other cuts with a lot more confidence.

Getting there meant treating the wheel like a precision part, not just a small one. Toolpath, workholding, runout, burr control, and how the cut actually leaves the edge all matter here. On a wheel, every visual choice also becomes a mechanical choice. If the cut looks right but shifts the part, raises burrs, or leaves inconsistent thickness, it is not done.

Second: we finally, finally achieved precision milling on both sides.

That sounds simple until you try to reference a tiny part twice and have both operations agree with each other. This has been one of those stubborn problems that keeps exposing every weak link in the chain: fixturing, alignment, zeroing, part handling, and process repeatability. You fix one source of error and the next one shows up. Then you fix that one too.

What changed is that both sides now locate and cut the way they are supposed to. The features actually line up. Thickness stays where it should. The part comes back from the second operation looking intentional instead of lucky. That is the difference: not a one-off success, but a process that is starting to behave.

These are still early steps, but they matter. Custom wheel cuts open up a lot of design room. Reliable two-sided precision milling opens up a lot more than design. It changes what parts we can realistically make, and how seriously we can hold the geometry.

So yes, two wins today. Not flashy ones. Just the kind that quietly expand the map.

Complex CAD models have a way of turning one small fix into a full afternoon. You go back to change one early feature, and suddenly half the history tree is red. References break. Sketches lose their parents. Things that looked stable start moving in ways you did not ask for.

That is not really a software problem. It is what happens when a design gets complicated enough that too many later decisions depend on too many earlier ones. A model can look clean on screen and still be held together by a few fragile assumptions that no longer make sense a month later.

I have been hitting that wall hard enough that I started changing the approach instead of just patching the fallout. Instead of manually repairing or rebuilding the design every time I want to change something fundamental, I am working on a script that generates the whole thing for me.

Why script it at all?

The point is not automation for its own sake. The point is to put the real rules of the part in one place. Critical dimensions, relationships, patterns, and repeated operations go into code. Then the model gets rebuilt from first principles each time.

If a core assumption changes, I change it once and regenerate instead of trying to keep a long chain of downstream features alive.

What the script forces you to confront

That has already been the useful part. A script is less forgiving than a messy feature tree. It forces you to decide what actually drives the geometry, what is derived from something else, and what was just a convenient number typed in at 1 a.m.

If the design depends on a rule, the rule should be visible.

A better way to think about the part

This also feels closer to how I want to think about making parts in the first place: define the setup, define the constraints, define the sequence, then make the part.

That is a better fit for precision work than treating CAD like a pile of cosmetic edits balanced on top of each other.

Still early, but promising

It is still early, but it already feels like the right direction. Less repair work. Less fear of touching the foundation. More room to test ideas without wrecking the whole model.

I will share more once the script is far enough along to show what it fixes, and what kinds of problems it creates on its own.

After six months away from the project, I’m finally starting again.

Getting back to it was not as simple as flipping the machine on and picking up where things left off. The real work was down in the hardware: machine setup, motor behavior, encoder feedback, and all the small details that decide whether a system is merely moving or actually moving with precision.

A big part of getting over that wall came from Alexis Paredes (@alexisparedesart on Instagram). Alexis put in the time, patience, and real attention needed to go deep into the setup with me. Not surface-level fixes, but the kind of careful troubleshooting that gets into the bones of the machine.

Thanks to that work, precision has finally been achieved in a way that feels solid and repeatable. That matters, because without trust in the hardware, everything that comes after is guesswork.

This restart feels different. Better grounded. Less about hoping the machine behaves, more about understanding why it does. That’s the kind of progress that actually holds.

So: the project is back on. And this time, it’s starting again from a much better place.

Thank you, Alexis.

Today I set up a new tool on the bench: a micro drill. It was inexpensive, I didn’t expect much from it, and honestly, I assumed it would be more of a curiosity than a serious addition. To my surprise, it performed better than expected — drilling clean holes as small as 0.3 mm in diameter. For anyone who has worked in watchmaking, that’s quite impressive for such a modest machine.

Comparisons and Expectations

When I purchased my Elara 2 and Lathe 3, I was advised that my existing equipment — a Sherline mill and a traditional watchmaker’s lathe — were toys, and would not provide the level of precision required for professional results. That seemed fair at the time; after all, these tools are often categorized as entry-level or hobby-grade.

Yet, a year later, the contrast has been eye-opening. While the larger machines have severle underferformed, this small micro drill has quietly demonstrated the ability to handle delicate work with confidence. It wasn’t supposed to be a precision hero, but in this case it has shown what’s possible on a smaller scale.

The Value of Simple Tools

There’s something encouraging about this. The micro drill isn’t overcomplicated, it isn’t marketed as cutting-edge, and it certainly didn’t cost a fortune. But it delivered where I needed it to. Sometimes, the simplest tools can step up in ways that more complex systems do not.

Looking Ahead

I won’t claim this micro drill replaces a full CNC, or that it solves all the challenges of watchmaking. But it has reminded me that progress can come from unexpected places. Tools often described as “entry-level” or “for hobbyists” still have their place in a serious workshop. And in this case, they’ve proven surprisingly capable — drilling holes that the more advanced machines have not yet been able to produce in my experience.

It’s a small victory, but one that keeps me motivated. Watchmaking is a long journey, and sometimes the most pleasant discoveries come from the tools you least expect.

It’s been a full year since the Elara 2 arrived in my workshop. In that time, I’ve poured countless hours into learning, testing, measuring, and refining. From CAM strategies in Fusion 360, to experimenting with feeds, speeds, and even multiple spring passes, this year has been an education in CNC machining unlike anything I could have imagined.

What I Learned

I didn’t step into this as an expert machinist. Quite the opposite. The Elara was supposed to be my bridge into precision watchmaking — a machine marketed with ±0.00001″ accuracy (0.0003 mm) and ±0.0002″ repeatability (0.005 mm). Numbers like that made it sound like a tool perfectly aligned with the microscopic tolerances of horology.

Over the year, I learned how much goes into producing reliable parts: tool deflection, thermal drift, motion control, encoders, and the subtle ways CAM paths can influence a cut. These lessons are valuable in their own right. But they’ve also been overshadowed by one stubborn truth.

Zero Parts Produced

Despite all the effort, I have not produced a single usable watch component on the Elara. Every test, every trial, has run into the same wall: the machine simply cannot hold the advertised precision.

• Air passes: about 4 microns off
• Cutting aluminum:
  • X-axis: ~33 µm off
  • Y-axis: ~50 µm off
  • Z-axis: ~85 µm off

For context: in watchmaking, a 50 µm error might as well be a canyon. Wheels don’t mesh, pinions don’t seat, plates don’t align. The promise of micron-level accuracy never showed up in practice.

The Gap Between Promise and Reality

It’s not that I haven’t tried. I’ve worked with outside engineers, tested with professional tools, and even reached out to NSCNC repeatedly. I’ve done everything a reasonable user could do. And yet, the reality remains: one year later, not a single part.

The most difficult part isn’t just the lost time. It’s the gap between expectation and reality. Buying a machine based on a specification that later gets revised downward isn’t just frustrating — it undermines trust.

Looking Ahead

While the Elara hasn’t delivered, the year hasn’t been wasted. I’ve learned more than I thought possible about machining, measurement, and persistence. And I’m already exploring new hardware paths, from upgrading motors and encoders, to rewriting the machine profiles from scratch. If anything, this experience has strengthened my resolve to keep going — because in watchmaking, persistence is the only way forward.

Still, the fact remains: after one year, the Elara has given me plenty of lessons, but zero parts. And that, more than anything, says what needs to be said about its precision.

One thing I never expected when I bought the Elara 2 was that a simple text file and a fragile license system could bring the entire machine to a halt. But that’s exactly what happened — not once, but multiple times.

The Case of the Corrupted Parameters

The parameters.ini file in Mach4 controls key settings for the machine. For reasons I still don’t fully understand, it sometimes corrupts itself. When that happens, the machine’s profile breaks completely. No alarms, no easy way to reset — just a dead profile that refuses to load.

Each time this happened, I reached out to support to ask: how do I fix it? Instead of a straightforward procedure or documentation, I was told to send files back and forth, with little clarity on what was actually going wrong. It left me with the sense that the software side of this machine had never really been built to recover gracefully.

The License Lockout

On top of that, the Mach4 license itself proved incredibly fragile. Changing a Windows username, updating the OS, or even small environment changes were enough to invalidate it. The license isn’t held by me as the owner — it’s held by NSCNC. That meant every time it failed, I had to go back to them for a new code.

When I asked for a replacement license, I was told I’d need to pay again. It felt less like a solution and more like a roadblock: instead of focusing on making parts, I was negotiating just to keep the machine running.

Why This Matters

For anyone considering a precision machine, stability matters just as much as accuracy. A CNC should not stop working because of a corrupted text file or a minor Windows change. And when it does, the path to a fix should be clear, documented, and included in the original cost of ownership.

Moving Forward

These experiences are why I’ve started building clean, replicable profiles from scratch. By writing my own macros, UI, and configuration files, I can control how the machine behaves — and avoid situations where a single corrupted file or license check renders it unusable.

I share this not to argue, but to document. Because at the end of the day, a watchmaker’s focus should be on precision parts, not corrupted INI files and unexpected license fees.

Read standalone post

The probe fixture finally made it from napkin sketch to finished CAD. I’ve queued the RFQ on mfg.com; the shop says about a month until brass chips fly on their end. Waiting is hard, but knowing the part will come back dead-square is worth it.

Macro M905 Still Steals the Show

While the fixture is off getting machined, the Lua macro keeps proving its value. In addition to auto-zeroing Z, it now lets me sweep the probe across the ceramic puck, sample two points, and calculate the tiny X/Y angle error of my current setup. Goal: drive that number to 0.000 ° before the new fixture lands.

Next Steps

• Wait for the part: ~4-week lead time from the shop.
• Tune the macro: refine the X/Y angle routine so the offsets drop into the table automatically.
• Full dress rehearsal: when the fixture arrives, clamp it, run M905, and watch the mill hit perfect zero with no hand-wheel drama.

If all goes to plan, the first probe touch in the new nest will read 0.000 on every axis. Fingers crossed—and spindles ready. 🔧⌚️

Fixture

First day turning pixels into golden curls! I sent a 0.4 mm carbide ball-nose through brass using a four-step plan (well, three plus a skip) and the chips did not disappoint.

What a week—literally. I built this entire setup in seven caffeine-soaked days, hit run, and hoped the cutter wouldn’t find a new way to redecorate my vise. Every spin of the spindle felt like a coin toss between triumph and catastrophic crash. Roller-coaster, meet workshop. 🎢

But the gamble paid off. I sent a 0.4 mm carbide ball-nose through brass using a four-step plan (well, three plus a skip) and the chips did not disappoint:

• Pass 0 – Rough shape: big step-overs, big chips.
• Pass 1 – Finer rough: tighter outline, heat still low.
• Pass 2 – Relief angle: light plunge to free the flanks before final form.
• Pass 3 – Skipped: brass ≠ tool—edge saved for the good stuff.
• Pass 4 – Gear-tooth detail: feather cuts that leave razor-sharp teeth (rapid plunge mellowed just enough!).

The result? Mirror-bright flanks, zero burrs, and—most importantly—no emergency e-stop drama. Still buzzing from the adrenaline.

Love watch-scale machining? Smash that like, drop your questions, and subscribe so you don’t miss the A-axis run-out test.

Big moment—time to push pixels into motion and see if the browser-based CAM sandbox behaves like a real machine. Spoiler: the cutters danced, the A-axis twirled, and I grinned like a kid with a brand-new loupe. 😊

Watching the path morph in real time made all those late-night refactors worth it. The spindle spins, the passes layer up, and the code footprint shrinks with every arc conversion.

Curious? Load the sandbox, drop a few points, and watch the tools trace air:

Explore the interactive toolpath playground →