u/Primary-Confusion504

If you run more than one local setup — ComfyUI, A1111/Forge, Fooocus, a kohya training env — you've probably noticed your models folder is way bigger than the sum of the unique models in it. A big chunk of that is the same supporting files copied over and over: the same VAE, the same CLIP / text encoders, the same upscalers, sitting byte-for-byte identical under a dozen different folders. Windows just keeps a full copy each time. How big that chunk actually is depends entirely on your own mix — how diverse your models are and how much those environments share — but the more setups you keep side by side, the more it stacks up.

NTFS can actually store one set of bytes under many names — hardlinks — so a file shows up everywhere it needs to but only takes the space once. The catch is the tooling: mklink /H one file at a time from an admin cmd isn't a workflow, and symlinks need admin or Developer Mode.

So I built PowerLink: point it at your models folders, it scans for byte-identical files (content-hashed, not just matching name and size), and replaces the duplicates with hardlinks. Every path keeps working — ComfyUI, A1111, whatever — because to those tools the file is still exactly where it was. Nothing moves, nothing re-downloads, the disk just shrinks.

For me this started when I needed a big chunk of disk back to work on another project. My models folder had crept up to around 1.5 TB — and because I keep a second copy of part of it for that other project, a huge share of that was literally the same files twice. Deduping with hardlinks took it down to about 650 GB — close to 850 GB back, without deleting a single model, and the second copy now costs almost nothing. Worth being clear though: how much you reclaim depends entirely on how much your setups overlap. If your models barely share supporting files you'll save little; mine just happened to be heavy on shared VAEs/encoders on top of that duplicate folder — so treat my number as one data point, not a promise. These days I just re-run the scan every so often after pulling new models: it catches the new duplicates, and re-running over files that are already linked is a harmless no-op, so it's become a routine cleanup rather than a one-off.

On prior art, to be upfront: the gold standard here is Link Shell Extension by Hermann Schinagl, which has done hardlinks, junctions and symlinks on Windows since 1999. I didn't build PowerLink because nothing existed — I built it because I think this genuinely belongs in PowerToys. There's an 8-year trail of PowerToys feature requests asking for exactly this (issue #2527 on GitHub and a stack of duplicates), all closed without anything ever shipping. So I deliberately built it on the PowerToys stack — WinUI 3 + C++/COM + .NET 8, with the core dedup logic kept UI-free — so it can actually be merged in as a module later instead of being yet another standalone tool.

A while back I built a Windows cursor that moves with physics (it rotates to point where you're heading, the loading spinners spin, the text caret wobbles like jelly) - it did well on r/csharp and r/Worms. But the part I actually use every day turned out to be dumber and more useful: when Claude Code is waiting on me, the cursor tells me. I fire off a long task, alt-tab away, and instead of babysitting the terminal or coming back two minutes late, a little Claude logo sprouts on my cursor the moment it needs input - and drops off when I take over.

How it works, briefly:

• It rides Claude Code's own hooks - an installer drops a command hook into ~/.claude/settings.json (Notification, Stop, SessionStart…).
• When one fires, Claude runs WormsCursor.exe hook --tool claude-code, which pipes a one-line event to the already-running tray app and exits in under half a second - fail-silent, so it can never hang or crash your session.
• While an agent is waiting, the cursor grows a tiny Claude logo that dangles off it on the same pendulum physics. Start typing and it clears.
• Multiple sessions stack: if several are waiting at once, a small +N rides on the logo - so you see how many need you at a glance, not just that one does. (Handy if you run a few terminals / worktrees in parallel.)
• No polling, no scraping the terminal - it only reacts to real events.

The thing that surprised me while building it: that physics cursor is Windows-only at a really deep level. It rests on SetSystemCursor - one system-wide cursor slot every app sees - and there's no clean public equivalent anywhere else. On macOS you can only do it via the private CoreGraphics APIs Apple breaks every release; on Wayland it's outright forbidden by design - a client isn't allowed to touch the cursor outside its own window. So "port the moving cursor" is closer to impossible-by-design than a weekend of work. But the "agent is waiting" signal is a totally separate, much lower bar - it's just reacting to a hook - so a cross-platform version of that (a menu-bar blip, a notification, a dock bounce) is easy. The fun part and the useful part turned out to be cleanly separable.

Which makes me think the real question is bigger than a cursor: as we run more agents async, "how do I know when the agent needs me?" is becoming its own little UX gap. Bells, notifications, Slack pings - none really fit the "heads-down in another window" case, and a cursor is a weirdly good channel precisely because it's already under your eyes. So how do you all actually know when Claude's done or blocked on you - hooks, a custom notifier, a second monitor, pure vibes? I don't think the good answers here have been built yet.

I built this for fun and posted it on r/Worms a few days ago - it got a surprisingly warm reception, and a fair few people there asked how it actually works. So it's clearly not just a thing for Worms fans, and I figured the .NET crowd might enjoy the technical side.

What it does: my mouse cursor rotates to point in the direction I'm moving it - like the aiming arrow in Worms 3D. Started as a weekend project and got out of hand.

How it works, roughly:

• WinForms system-tray app (.NET 8), no window.
• A mouse hook tracks the cursor position; I compute the movement angle from the delta between frames.
• I render the cursor bitmap rotated to that angle and swap it system-wide via SetSystemCursor.
• Then I couldn't stop, so I themed all 14 standard cursors with little physics: the wait/busy cursors spin with rotating rings, the I-beam sways, resize cursors stretch.
• Packaging + auto-update via Velopack.

The fiddly parts: smoothing the rotation (raw angle is jittery, needed easing), and restoring the original cursors cleanly on exit so you don't get stuck with a spinning arrow if it crashes.

It's open source (MIT) if you want to poke at the code - repo link in the comments. Happy to answer anything about the cursor-hooking side, it was a fun rabbit hole.

EDIT: Repo link: https://github.com/dawidope/WormsCursor