Hey everyone,

Quick progress update on VaultSync v1.7.4.

This is not the final release post yet, but the release branch is getting close enough that I wanted to share what changed, what has been hardened, and what still needs testing before I cut the release.

The short version: v1.7.4 is mostly a stability and release-readiness update. It moves VaultSync to .NET 10, improves backup safety, fixes several metadata import edge cases, cleans up diagnostics, and prepares better Linux packaging.

Main changes

Safer backup behavior

A lot of the backup work in v1.7.4 is about making VaultSync fail safer.

One important fix prevents recursive backup growth. In some edge cases, especially around unavailable external or network destinations, backup output could end up somewhere that later runs might scan again.

VaultSync now has centralized source/destination safety checks and reserved backup-artifact exclusions, so it should not back up its own backup output.

Backup cleanup is also more conservative now.

VaultSync can prune stale database entries when the recorded backup folder is missing from a destination that is actually reachable. But if a drive is offline, disconnected, sleeping, or unresolved, VaultSync should not assume the backup was deleted.

That should help avoid false cleanup behavior around external drives, NAS paths, or temporary mount issues.

Metadata import hardening

Metadata import got a lot of attention in this update.

Some of the main improvements:

• Startup metadata import now checks reachable backup destinations
• Source stores are treated as read-only during UI imports
• Linux rooted backup paths can be remapped to the active destination
• SQLite sidecar journal files can be recovered through a temporary copy
• Missing backup history can be rebuilt from timestamped backup folders
• Locked tombstone exports are deferred locally for retry instead of being dropped
• Manual metadata refresh should no longer hang the UI or map temporary roots

This should make VaultSync more reliable when moving metadata between machines, recovering a destination, or working with Linux-mounted backup locations.

Linux packaging improvements

Linux tarballs now include rootless install/uninstall scripts.

The install flow sets up the launcher, icon, and vaultsync command without needing a system-wide installer.

I also added VS Code Linux debug configs for the UI, CLI, and tests to make Linux-side development less awkward.

Linux-specific fixes also landed around tray behavior, metadata path mapping, mounted backup destinations, and debug build crashes.

Cleaner diagnostics and logs

The in-app log console has been cleaned up so rows are easier to read, with clearer time/source/message fields while still preserving the raw log lines for copying and export.

Runtime errors are now captured in the in-app logs without needing verbose logging first.

Normal app runs should also no longer show caught first-chance SQLite/WinRT probe exceptions in diagnostics unless first-chance diagnostics are explicitly enabled.

Those were internally handled provider/framework probes, but they made normal logs look scarier than they were.

The log console copy button was also fixed to use the console window clipboard instead of relying only on the main window.

Backups page is less noisy

Passive Backups refreshes no longer wake destinations just to update reachability.

That means VaultSync should be less annoying around sleeping drives, unavailable network shares, or disconnected storage.

It should only touch those destinations when it actually needs to, such as during backup execution or manual tests.

Backup delete and progress visibility

Backup delete cards now stay visible and show more useful deletion progress details.

This should make overlapping or longer delete operations less mysterious, especially when VaultSync is removing larger backup trees.

.NET 10 migration

VaultSync Core, CLI, UI, and tests have been moved to .NET 10.

That also meant updating release scripts, CI/release asset paths, publish commands, installer metadata, and development docs around the new target framework.

This is one of the larger internal changes in this update, but the goal is simple: keep the project current and make the next releases easier to maintain.

Development preset cleanup

The built-in development presets now skip more nested generated output folders, including things like:

• **/bin/**
• **/Intermediate/**
• .import
• render/cache style folders

This should reduce backup noise for projects that generate build/cache files deep inside the project tree.

What’s New popup cleanup

The in-app What’s New dialog has been redesigned into more of a release digest.

It also now reads only the current release section instead of accidentally carrying older changelog sections into the dialog.

Smaller cleanup

There was also some internal cleanup to reduce duplicated code, including shared helpers for:

• Byte-size formatting
• Detached async command handling
• Backup path containment
• Config write retry behavior
• CLI JSON serialization

Nothing flashy, but it should make the codebase easier to maintain and reduce slightly different implementations of the same logic.

Thanks again for the patience and for all the bug reports. A lot of this release is directly aimed at the edge cases people have been hitting in real use.

And as always: keep backing up your data.

Woke up to a pretty nice number today.

VaultSync has now passed 800 downloads.

https://preview.redd.it/i4astdz5z2zg1.png?width=692&format=png&auto=webp&s=081bc0033c7fa10b293070739ab150dfc92e3c30

I know it isn’t huge in the grand scheme of things, but for me it’s one of those small moments where the project feels a bit more real.

This started as something I was building mostly for myself, so seeing more people slowly try it, test it, give feedback, and follow along has been genuinely motivating.

Especially because VaultSync is not the kind of app people download just to look at for 30 seconds. It’s backup software. If someone installs it, tests it, or starts trusting it with their files, that means something.

A lot has happened recently:

• the Microsoft Store launch
• the first proper Linux beta release
• the website going live
• a lot of behind-the-scenes work to make the app more solid going forward

So hitting 800 now feels like a really nice moment in the middle of all that.

More than the number itself, what matters to me is that people are actually trying it, giving feedback, reporting issues, suggesting improvements, and helping shape where it goes next.

So yeah, just wanted to say thank you.

To everyone who downloaded it, tested it, broke it, reported things, suggested ideas, or even just followed along: it genuinely means a lot.

Onward to the next milestone.

And as always, keep backing up your data.

Hi everyone,

Quick warning: there are reports that the latest Windows security update is breaking or disrupting several third-party backup applications.

VaultSync is currently being tested against this. I do not yet have enough information to say that VaultSync is affected, but because this seems to involve backup software more broadly, I want to treat it as urgent.

If you use VaultSync on Windows, your reports are extremely valuable right now.

Please let me know if you notice:

- failed backups
- permission/access errors
- unreachable destinations
- restore problems
- verification errors
- crashes
- anything that started after the latest Windows update

Useful details:

- Windows version
- VaultSync version
- destination type: local, USB, NAS, SMB, etc.
- error message or log snippet
- whether the issue started after installing the latest Windows update

Until this is clearer, please verify that your backups are still completing correctly and consider testing a small restore.

I will continue testing and post updates as soon as I have confirmed information.

Update:

Good news: from everything I can see so far, VaultSync does not seem to be affected by this Windows backup-tool issue.

The reports going around appear to be related to backup tools that depend on Windows VSS snapshots or image-mount drivers. VaultSync does not use that kind of backup path. On Windows, VaultSync is mostly working through normal file copy/sync/archive flows, such as robocopy/rsync, managed file copy, ZIP/archive snapshots, and optional network-share handling.

I tested the parts that matter most:

• snapshot / sync / verify passed
• writing to the backup destination worked
• targeted backup into the destination completed and verified correctly

So for now, VaultSync looks safe from this specific issue.

I’ll keep watching this and testing more, but the current state is positive.

If anyone sees different behavior on their machine, please still report it. Real-world reports are always useful, especially with your Windows version, VaultSync version, destination type, and any error/log message.

Big milestone on this one.

VaultSync 1.7.3 beta is out, and with it comes the first proper Linux beta launch.

This is something that has been requested for a long time, and it feels really good to finally have Linux builds going out as actual release assets instead of it staying in the “later” pile.

This beta now ships with:

• Linux tar.gz builds for x64 and arm64
• a desktop-friendly linux-x64 AppImage
• improved Linux update asset detection so the app can prefer the right architecture-specific packages

So this is the first real step toward giving Linux users a proper way to try VaultSync.

A big part of that is that most of the Linux work behind this release was done by JustH8Me.

They’ve been doing real work on the Linux side and helped push this forward in a meaningful way, and this beta release simply would not look the same without that contribution.

That work already landed in some very real fixes:

• tray panel screen detection, reopen behavior, and Wayland positioning improvements on Hyprland-style environments
• tooltip flickering and focus fixes on Linux/Wayland
• a fix for a fatal AccessViolationException on Linux x64 during backup
• a fix for passwords being saved as "null" on Linux, plus increased timeout handling

So this is not just “Linux builds exist now”, it’s also the result of actual Linux-focused work being done and landing in the app.

On top of that, 1.7.3 beta also includes a couple of smaller quality-of-life improvements:

• the in-app log console now has an explicit Auto-scroll toggle
• you can now copy the selected log line with a button or the normal platform copy shortcut

And there are also a few fixes on the general app side:

• Settings now refreshes persisted values correctly after config reloads
• startup now repairs blank project root paths from the configured Projects root when possible, which should reduce some relaunch-related missing path issues

This is a beta release, so I’d especially appreciate testing and feedback here — even more so on Linux since this is the first proper beta push for that platform.

If you try it, let me know how it behaves on your setup.

Thanks again to everyone following the project, testing builds, reporting issues, and contributing.

And a special thanks again to JustH8Me — most of the Linux work in this release came from them, and it made a real difference.

As always, keep backing up your data.

Figured it was probably time for a proper update on where VaultSync is at right now, because a lot has happened recently, even if not all of it looked like big flashy feature work from the outside.

Over the last stretch, a lot of time went into things that were important, but not always very visible.

VaultSync is now live on the Microsoft Store, which was a pretty big milestone for me. That took more than just packaging the app and uploading it somewhere. It meant adding proper Store-aware behavior, separating Direct and Store update paths, making sure the app understands how it was installed, and getting that whole side of distribution into a state I’m comfortable with.

At the same time, I also launched fglabs.dev, which is basically the new home for all my work going forward, including VaultSync. That was something I had wanted for a while because everything was too scattered before — GitHub, posts, docs, random links. Now there’s finally one place where things connect a bit better.

And alongside that, a lot of the 1.7 work has been less about adding things for the sake of it and more about getting the app into a better state internally.

A lot of older code was functional, but it was starting to push back every time I tried to optimize something or build new features on top of it. So a good part of recent updates has really been cleanup in the deeper sense — not just polish, but rewriting parts that had become limiting.

That includes things like:

• reducing unnecessary config reloads
• improving startup behavior
• backing off bad destination checks instead of hammering unavailable targets
• fixing UI refresh timing and thread-related issues
• cleaning up hardcoded fallback text and localization gaps
• making metadata sync and project state handling more reliable across machines

None of that is the kind of work that makes for a dramatic screenshot, but it matters a lot for backup software. If the app feels weird, stalls, misreports, or behaves inconsistently depending on timing or machine state, that becomes a real problem fast.

Another thing that happened recently, and that honestly means a lot to me, is that VaultSync now has someone actively helping with Linux.

What made that hit differently is that it didn’t come from me trying to force it or recruit someone just to tick a box. It came from someone who genuinely likes the project, took the time to dig into it, ask questions, understand how parts of it work, and start trying to move Linux support forward because they wanted to help.

That kind of thing matters a lot more than people probably realize, especially on a small project like this.

Linux has been one of the most requested things for a while, and I’ve wanted to get there properly rather than throw out something half-broken just to say it exists. So having someone step in because they actually care about the app and want to contribute is a pretty big moment for VaultSync.

I’m not going to overpromise timelines there yet, but it’s no longer just sitting in the “eventually” pile.

As for what’s next, the focus is still on making VaultSync more solid before I start stacking bigger things on top of it.

The areas I’m most interested in pushing next are:

• more transfer system improvements
• better handling for larger backups and long-running vaults
• continued UI cleanup where things still feel rough or waste space
• more reliability around backup state, metadata, and restore-related flows
• making the app easier to reason about when something goes wrong
• continuing progress toward a proper Linux release

There’s also still work to do around the Store version and release flow now that that path is real and live.

So updates may continue to be a bit slower than they used to be, but that’s mostly because the project is at the point where doing things properly matters more than just shipping fast.

I’d rather take a bit longer and build on something solid than stack more features on top of shaky parts and regret it later.

VaultSync is moving forward, very much so. The pace is just a bit more deliberate now.

Also, we have surpassed 700 downloads, which is honestly wild to me.

So yeah — that’s where things are at right now.

Thanks again to everyone who’s been trying VaultSync, giving feedback, reporting issues, or just following along. It really does help shape what this turns into.

And as always, keep backing up your data.

I’ve been working on this quietly for a while, and it’s finally at a point where I can put it out properly.

I launched fglabs.dev — a home for the stuff I’m building in public The whole point is to give each project enough context, proof, and personality to stand on its own.  

Up to now, everything was split across GitHub, posts, release notes, random docs, and whatever link made sense at the time. This is me fixing that and giving the work a proper front door.  

Right now the site is split pretty cleanly.

Products is the software side. VaultSync is the most mature thing there right now, and Blueprints is the next software product taking shape.  

Play is the game-dev side. Fusion Grid is the first real playable in that lane, and that section is where future prototypes and game work will live.  

There’s also FAQ and About, because I wanted a place for quick answers, support direction, how the site is structured, and a clearer explanation of how I work and why these projects exist in the first place.  

What I wanted, more than anything, was one place where someone can land and actually understand what I’m doing without needing ten tabs open first. The software and game-dev work are different tracks, and the site reflects that instead of forcing everything into one generic shape.  

VaultSync is still the most complete product on there right now, with active releases, installers, and a Store listing, but the goal of the site is bigger than VaultSync. It’s meant to be the base for everything I’m building going forward — software, prototypes, and playable ideas.  

It’s still early, but the foundation is there now.

Site is here: https://fglabs.dev/

If you check it out and something feels off, unclear, or missing, tell me.

Woke up to this today.

VaultSync is now officially live on the Microsoft Store.

https://preview.redd.it/0ejl7bb4zbug1.png?width=2406&format=png&auto=webp&s=c0af9fafe4a77d3df7c82557879396be4713eb0f

This has been something I’ve been working towards in the background for a while, and seeing it actually go through certification and show up live is… a bit surreal.

For anyone wondering:

• it’s the same app as the GitHub version
• no locked features
• no subscriptions
• still fully open source

The only difference is distribution.

Right now it’s free, and later on it will move to around €1.99 as an optional way to support development.

Nothing changes if you prefer downloading from GitHub — that will always stay free.

This also ties into the recent 1.7.2 update, which included a lot of behind-the-scenes work to support Store packaging, update handling, and making sure both versions can coexist properly.

Also… we’re just about to hit 700 downloads, which is honestly crazy to think about.

https://preview.redd.it/9f2mw2wczbug1.png?width=449&format=png&auto=webp&s=b65ba5d741ae60adc88c46dcaa0f1eaf81bf31d6

Thanks to everyone who’s been trying VaultSync, giving feedback, or just following along — it really means a lot.

And as always, keep backing up your data.

Quick update — and a pretty big one this time.

VaultSync has officially entered Microsoft Store certification.

https://preview.redd.it/83y579t0z6ug1.png?width=1624&format=png&auto=webp&s=ae10188ff34fbb9b9fce550c22fec0385ab33eeb

This has been something I’ve been working on in the background for a while, and it’s finally at the point where it’s going through the actual submission process.

If everything goes well, VaultSync will soon be available directly through the Store.

At the same time, I’ve been pushing forward with 1.7.2, which lays a lot of the groundwork needed to support this properly.

What’s new in 1.7.2

A lot of this release is focused around supporting the Store version without breaking the current GitHub workflow.

Some of the key changes:

• VaultSync can now detect how it was installed (Direct vs Microsoft Store)
• Store builds disable the GitHub self-updater and instead rely on Store-managed updates
• Added a separate build pipeline specifically for Microsoft Store packages
• Introduced the first full Store packaging setup with Partner Center integration

On top of that, there’s also a bunch of improvements and fixes:

• checkpointed archive uploads now properly resume even with parallel transfers
• compression progress is now visible instead of appearing frozen on large files
• metadata sync is more reliable across machines (tags, destinations, auto-backup state)
• deleted projects won’t randomly come back from destination metadata anymore
• better handling of disappearing files during scans (less noise, fewer edge-case errors)
• improved UI responsiveness and layout in Settings (especially on smaller screens / scaling)
• toast notifications are now cleaner, deduplicated, and more usable

About the Microsoft Store version

The plan is simple:

• it will be identical to the GitHub version
• no locked features
• no paywalls
• still fully open source

The only difference is distribution.

The Store version will be free at launch, and will later be priced at €1.99 as a completely optional way to support development.

Nothing changes if you keep using GitHub releases — they remain free as always.

Small milestone

We’re also just a few downloads away from 700 total downloads, which is honestly crazy to see.

https://preview.redd.it/ufvn3oo1z6ug1.png?width=460&format=png&auto=webp&s=927f2819c6e46741113c3f4dab387cc708e29c8e

Really appreciate everyone who’s tried VaultSync, given feedback, or even just followed along — it means a lot.

Where things are going

This is also part of a bigger shift that I mentioned recently.

A lot of current work is focused on:

• making systems more solid internally
• improving long-term maintainability
• making sure new features don’t sit on unstable foundations

Which is also why updates have been a bit slower — but much more deliberate.

That’s it for now.

Seeing VaultSync reach this point (and now going through Store certification) is honestly pretty surreal.

Thanks again for all the support — and as always, keep backing up your data.

I think it’s time to give a bit more insight into where VaultSync is at.

You’ve probably noticed updates have slowed down a bit after 1.6 — and that’s going to continue for a while.
It’s not because development stopped. It’s actually the opposite.

Right now most of the work isn’t feature work. It’s going back through the app and fixing things that were working, but not in a state I’m comfortable building on long-term.

There’s a fair amount of older code that, while functional, was starting to get in the way of adding new features and properly optimizing the app. So a lot of the recent patches have been about rewriting parts of it based on what I’ve learned along the way and, honestly, out of necessity.

Config access (example)

There were a lot of places where the app was reloading config from disk even for read-only operations. On their own those weren’t a big deal, but across the whole app it added up to unnecessary disk hits, UI stalls, and heavier startup than it should be.

Fixing that properly meant reworking how shared state is handled, how snapshots are cached, and how fallback reads behave when the main state isn’t ready yet. It ended up touching way more of the app than expected.

Startup and background behavior

Too much was happening immediately on launch, and too many things were competing at the same time. On top of that, remote targets (NAS, external drives, etc.) could drag everything down if they weren’t available.

So a lot of time has gone into:

• deferring work
• pacing things better
• backing off failed destination checks
• avoiding re-hitting known offline targets immediately

And that kind of work is annoying because every time you fix one place, you find two more doing something similar.

The “small” issues that weren’t small

There’s also been a bunch of issues that sound minor but weren’t once I dug into them.

Things like:

• dashboard refresh timing
• UI updates happening on the wrong thread
• data showing up only because timing happened to work
• duplicate or conflicting states

None of it is exciting, but it’s the difference between something feeling solid and something feeling slightly off all the time.

Localization

There was still way too much hardcoded text in random fallback paths — dialogs, tray UI, missing states, settings, etc.

Cleaning that up isn’t just replacing strings, it’s making sure everything resolves correctly everywhere, which takes time.

Microsoft Store

On top of all that, I’ve also been working on getting VaultSync onto the Microsoft Store.

That’s been a bit of a side project, but it’s actually quite a bit of work — packaging, metadata, versioning, making sure updates behave properly in that environment.

The idea is simple:

• the Store version will be the exact same as the GitHub one
• no locked features, no paywalls
• still fully open source

It’ll probably be around €0.99 — just as an optional way to support development if you want to.

Nothing changes if you keep using GitHub releases.

So yeah, that’s why things are slower right now.

Up to now development has been pretty fast and feature-driven, but at this point almost everything touches everything else — transfers, metadata, UI, restore logic, destinations, cross-machine stuff.

So doing things properly just takes longer.

Updates will still come, just a bit slower and more deliberate.

I’d rather do that now than keep pushing fast and end up with something that’s harder to maintain later. Especially for backup software, that trade-off feels worth it.

That’s pretty much it.

Thank you for the continuous support and even just trying VaultSync — it genuinely means a lot.

We’ve also passed 600 downloads since launch, which is honestly incredible. We can only grow from here.

Thanks again, and keep backing up your data.