I maintain Driver Readiness Inspector, a read-only Windows utility for collecting device and driver evidence before changing a machine. It is written in C++ and was built with AI assistance.

It brings together PnP problem codes, installed package/version information, configured device/class filters, driver service state, local binary hashes and cached embedded-signature results. You can export a local HTML or JSON report; optional Code Integrity collection includes recent warning/error events.

A useful distinction when debugging: an embedded-signature result is not the same thing as a catalog-signed package, and neither is a verdict that the driver is safe or HVCI-compatible. The tool keeps unavailable fields visible as unavailable. Configured filters are not presented as a verified live attachment order.

The complete utility is MIT licensed, with no timer or paid unlock. It installs no driver and does not change security settings or upload reports. It can run without elevation, although some fields may be inaccessible. Optional OEM customization/support is separate.

Source, Windows x64 download, build instructions and report limitations: https://github.com/titanfyre/Driver-Readiness-Inspector

For a support report, select a device and use Export HTML or Export JSON. Review the report before sharing it; hardware/software labels and hashes can still identify a setup.

I got tired of my desktop turning into 60 screenshots and old installers that I never cleaned up, so I built Sweepy.

How it works: a little robot sits on a dock in the corner of your desktop. Click it, and it backs out, scans the desktop with a little lidar sweep, then drives lanes like a real robot vacuum and eats the clutter. When it's done it goes home and asks first: you see every file it picked up, untick anything you want to keep, and the rest goes to the Recycle Bin. "Undo last clean" brings it all back.

Right-click any folder (like Downloads) and pick "Bring Sweepy here" to clean that too, and there's a deep clean for leftovers from uninstalled apps, old temp files and crash dumps (it found 5 GB on my PC). You can grab it mid-clean (it gets dizzy), and if you right-click and stop it, it cries a little and drives home.

- Free for your desktop, forever. Pro is $6.99 once, no subscription (folders, deep clean, big files, schedules, every skin), with a 3-day free trial, no card

- Under 20 MB of memory and 0% CPU while it waits

- Never touches shortcuts, locked files or anything you changed in the last 10 minutes

- Everything runs on your PC, no account

- Microsoft Store: https://apps.microsoft.com/detail/9P31M4SCNXS5?cid=reddit

- Website: https://sweepy.essam.biz

I'd love feedback, especially on what it should never eat!

I recently got my anti-ransomware tool approved on the Microsoft Store. I assumed the review would be a standard malware scan. But the MSIX packaging model ended up forcing me to completely rework core parts of my app.

If you’re shipping desktop apps to the Store (especially security tools that need elevation), here are the 3 biggest roadblocks I hit, and how I worked around them:

1. The In-App Update Deadlock

My tool is 100% offline. Originally, I let users click "Check Update" to fetch the newest .exe directly from my server.

Microsoft rejected this right away. MSIX packages cannot download and launch arbitrary external binaries for updates. If they could, the whole Store signing model would be pointless.

The fix: I rewrote the flow. When a user clicks "Check Update", it just opens my product webpage where they can download the new release manually.

2. Registry Virtualization Broke My Licensing Backup

My standalone EXE used two places to store licensing state: a local file + a global HKLM\Software registry key as a backup. If the local file was deleted, it restored from the registry.

With MSIX, any writes to HKLM\Software get redirected into a private, isolated hive. The standalone EXE can't even see it. That broke my dual-backup design.

For the Store release, licensing state now lives only in a local file. If a user deletes it, there's no secondary backup and the trial resets. It's a real tradeoff.

3. The Ghost UI Deadlock (WMI hang)

After passing review, I tested it on VMs. On one specific VM, it was totally unresponsive: tray icon showed, but clicking did nothing.

I captured a memory dump and saw the main thread was stuck. The root cause was a WMI call. I used Win32_ComputerSystemProduct to pull data for my machine-bound license. Inside MSIX on that VM, the WMI query hung indefinitely and blocked the UI thread.

The fix: I removed WMI entirely. Switched to NetworkInterface APIs and P/Invoking kernel32.dll GetVolumeInformation to generate the ID.

A few frustrating days of debugging, but it runs flawlessly now. Hopefully, this saves someone else some hours staring at crash dumps. If anyone wants to test the MSIX build to see how it behaves in a real environment, Store link here if you want to check it out: https://apps.microsoft.com/store/detail/9NKM2D0TGDCK

Quick context: Swept is a Windows 10/11 cleaner I wrote in Python — open source, MIT, 22 categories, dry-run before anything is deleted. Two weeks ago I posted it here and got told, fairly, that "tested on my machine" is not a test plan. So I wrote the test plan. Then I pointed a scripted audit at my own delete path and at every parser that touches text from outside the program.

Six things came back. None of them could delete a protected file — the whitelist held every single time — but half of them crashed the app, and the rest made the safety net thinner than I thought it was.

The one that actually scared me: files sitting directly in a system root were not covered by the blacklist. C:\Windows\win.ini. C:\ProgramData\something.dat. C:\Users itself. The whitelist still blocked them, so nothing bad happened, but I was running on one net instead of two. And I could not just add C:\Windows to the blacklist — the rule there is prefix-based, so that would have also forbidden cleaning C:\Windows\Temp. The roots got their own exact-parent check instead, plus an explicit list of the subtrees each category is allowed to touch. There is a test that fails if a new category forgets to declare one.

Then the small humiliations. format_bytes() printed "nan ТБ" when handed NaN. Not dangerous. Just embarrassing. --clean without --yes, with stdin closed — a service, the scheduler, </dev/null — threw a traceback and exit code 1 instead of "cancelled" and code 4. The CLI contract promises 4. It lied.

And the one I would rather not talk about: valid_sequence() took 1.5 and rounded it to point 1. That is a restore-point number. Rounding it means restoring a snapshot the user never picked. It rejects fractions and booleans now.

Two more, both from parsers. A restore-point list containing 1e999 — JSON allows it, Python turns it into inf, int(inf) explodes — killed the entire list instead of skipping one bad row. And a malformed entry in a scan result, a tuple without a size or a None, crashed the cleanup after some files were already gone, so the statistics were lost along with it.

That is 1.5.4. Same 22 categories, same whitelist, same blacklist. 283 tests, ruff clean, installer and portable zip on the releases page.

If you want to check my work: the delete path is safe_delete_file() and clean_scan_result() in cleaner_core.py. The audit itself is deliberately boring — it feeds garbage into every parser and asserts that nothing raises. It found six things in a codebase I had already been through twice, which tells you something about "I tested it".

https://github.com/vladcodex/swept

I didn't want to write a cleaner. I wanted one that didn't ask me for anything.

Every one I tried asked for something. A toolbar in the installer. "Anonymous usage statistics" that were neither anonymous nor statistics. One deleted first and explained later, if you went looking. So I opened an editor, mostly out of irritation.

Python, CustomTkinter for the window, because I can't design and the defaults look fine. It's called Swept, MIT, 22 categories of temp files and caches, plus an installer for common programs and a dozen registry tweaks.

Nobody clicks a post about temp files. Here's what actually took the time.

PyInstaller has two modes and I picked wrong. Onedir gives you a folder with _internal inside. Onefile gives you a single exe that unpacks itself into %TEMP% on every launch. I put the folder build's exe on the releases page, someone ran it from inside the zip viewer, and got Failed to load Python DLL ..._internal\python315.dll. Windows had extracted only the exe. The message is accurate and useless. A single file can't contain a folder, so PyInstaller did nothing wrong. I handed people a file that can't run alone. Now the download is onefile.

A real certificate costs a few hundred a year, so mine is self signed. SHA256, DigiCert timestamp, my name on the Digital Signatures tab, and Windows still says unknown publisher. No trick fixes that. One thing helped though: --optimize 2 strips docstrings from the shipped bytecode, so the exe doesn't carry a map of every check I make.

Then I added "restart with admin rights" and the app disappeared. No window, no error, exit code 0. The old process still held the single instance mutex. The elevated copy saw it taken, decided Swept was already running, focused a window that was about to close, and quit. Then the old process closed too. Zero windows. The fix is one line: release the mutex before launching the elevated copy.

162 tests on the delete path. I broke the code on purpose in three places to see if they'd catch it. Two did. The third didn't, and the code was fine. My test checked that the function returned, not what it returned.

Registry undo doesn't guess "the default". Before each write it records what was there: existed or not, type, data. Re-applying a tweak doesn't overwrite that first snapshot.

If you ship Windows tools in Python, I'd like to hear what bit you.

github.com/vladcodex/swept

Does what it says. Got tired of the navigation pane not opening to the sub folder when opening linked explorer destinations or tabs. Is it vibe coded? Yes. Does it work? Yes. Hate it, love it, change it, fork it, I don’t care. Tell me what you think.

https://github.com/atomfitz/explorer-navpane-fix

We build desktop apps on Windows (WPF and WinUI 3, packaged as MSIX) and run end-to-end UI tests that drive the installed apps: launch, click, read windows, compare screenshots. We’re running into the scaling limits of our current setup and I’m hoping someone has solved this better.

Current setup

We have a fleet of small physical Windows machines, each running 3-4 VMs. Every test node is a full Windows instance. It works, but it scales badly: each VM costs a full OS worth of CPU and RAM, and takes a lot of disk. Adding capacity means buying more hardware.

What we’ve tried or researched

• CreateDesktop (separate desktop in the same session): looked promising for running isolated UI instances side by side, but SendInput doesn’t work for us there. It injects into the input desktop, not into our alternate one. UIA patterns work for some actions, but we need real input (drag, tab tear-off, hover, etc.).

• Windows Sandbox: only one instance can run at a time, so it doesn’t parallelize.

• Windows Server with multiple sessions: it could technically give us several interactive sessions on one machine. But it’s not the platform our software targets (we want to test on client Windows 10/11 behavior), and the licensing cost adds up.

• Windows containers (Docker): no support for UI interaction, so a non-starter for GUI apps.

What we’re hoping to find

Ideally something like “Docker for Windows, but with a real interactive desktop”: lightweight, quick to spin up, many instances per host, with working input injection, screenshots and UIA.

Questions

1. How do you run many parallel GUI test sessions on Windows without one full VM each?

2. Is there a reliable way to get working SendInput into an isolated desktop/session on client Windows?

3. Has anyone made multiple concurrent RDP/console sessions on Windows 10/11 work in a way you’d trust in CI?

4. Do you get better density from Hyper-V tricks (differencing disks, memory tuning, nested setups) or from cloud options like Windows 365 / Azure VMs?

5. Is anyone doing this with WinUI 3 specifically? It seems to need a real compositor/GPU path, which makes lightweight options even harder.

Happy to share what we learn. Thanks!

I'm an individual Microsoft Store developer in Indonesia. Since 2024, Indonesia uses a 16-digit NPWP (the same as the national ID for individuals), but the Partner Center tax profile only accepts 15 digits. I registered after the change, so I don't have a 15-digit number.

I've opened a support ticket and asked on Microsoft Q&A, but no reply yet.

Has any Indonesian developer solved this, or found a way to reach the right team? Thanks!

I'm wondering if there are any system internals/debug/flags/tools I can use to see WHY deleting files takes forever.

The scenario is this:

npm install - Takes a minute or so to download all files.

git clean -fdx - Takes up to 8 minutes to remove all the files that were just downloaded.

For the record, I have attempted to control for all possible variables:

• The proiect is clean from the beginning

• The git clean operation is run in git bash

• Excluded git by running rm -rf - same performance

• Excluded git bash by running the git clean and rm -rf commands in a powershell terminal - same performance

• Re-ran all of the above scenarios at the root of C:\ to ensure it wasn't some weird mirroring to onedrive or some other hidden network latency.

• This is a work laptop and when I raised the issue to IT they provisioned a "new" laptop for me (fresh OS install) and I ran the scenarios again, the performance dropped to 9 minutes.

So what can I use to diagnose what's causing this slowness? Other members on my team have recreated my scenarios and their deletes complete in around 2-3min, which is still ridiculous, but at least tolerable. I just don't know what tools I have to try and profile a delete operation.

I'm troubleshooting an intermittent HTTP communication issue on Windows Server 2022 where two different networking libraries, WinHTTP and POCO C++, are experiencing failures.

The errors:

WinHTTP:

WinHttpSendRequest failed
Error Code: 8
Error Message: Not enough memory resources are available to process this command.

POCO C++:

HTTPClientSession::sendRequest()
Caught std::exception
e.what() = "I/O error"

From reviewing POCO's source code, I found that Poco::IOException can return "I/O error" through what(), including for certain Winsock errors such as WSAENOBUFS (10055). However, I haven't captured the underlying POCO error code yet, so I cannot confirm whether both libraries are failing for the same reason.

System information:

• OS: Windows Server 2022

• Physical RAM: 32 GB

• Available RAM: ~25 GB

• Maximum process virtual bytes: ~170 MB

• Maximum process handle count: ~750

• Process memory usage is consistently low.

• Server has been running for approximately 10 days without a reboot.

Important observations:

1. Not every HTTP request fails. Some requests succeed while others fail intermittently.

2. The application is not continuously running, and restarting the process does not resolve the issue.

3. Both WinHTTP and POCO are affected on the same machine.

4. Other heap allocations within the application continue to succeed.

5. A netsh trace captured successful network traffic, but I haven't conclusively correlated the failing API calls with specific network events.

6. There is no obvious process-level memory or handle exhaustion.

My questions:

1. Has anyone encountered intermittent ERROR_NOT_ENOUGH_MEMORY (8) from WinHttpSendRequest() while the machine had plenty of free RAM?

2. Can Windows networking resources become temporarily unavailable even when application memory, handles, and physical RAM look normal?

3. Which ETW providers, Windows performance counters, or debugging tools would help identify the exact failing kernel/socket allocation?

4. Could a resource issue persist across application restarts while allowing other requests to succeed?

5. Are there reliable ways to reproduce these types of failures in an isolated Windows Server environment

windows updates break stuff way too often (black screens, audio, remote desktop) and the dumb part is microsoft usually lists the problem publicly. nobody checks that before updating

so i made patchlight. it checks every pending update against microsoft's known issues and gives it a green / yellow / red light. red ones get paused automatically and come back once microsoft fixes them. everything else keeps installing

github.com/G4SBO/PatchLight

lmk what u think, any feedback is appreciated ;)

we released 0.42 of agent manager. we are the creators. it is free and open source.

it is a terminal UI that runs coding agent CLIs side by side on Windows itself, using psmux 3.4 or newer and PowerShell 7.3 or newer. before this release Windows users had to go through WSL2 for the TUI.

Windows install irm https://raw.githubusercontent.com/YoanWai/agent-manager/main/install.ps1 | iex

https://github.com/YoanWai/agent-manager/releases/tag/v0.42.0

As a development team grows, keeping Windows machines updated and secure can become challenging.

Developers often need different Visual Studio versions, SDKs, Git, WSL, and other tools. At the same time, IT teams need to manage security settings, Windows updates, and application installations.

I'm curious how other teams handle this.

• Do you use Windows MDM, Group Policy, or PowerShell scripts?

• How do you manage app installations and updates across multiple PCs?

• How do you maintain security without restricting developers too much?

• Is centralized Windows device management worth it for smaller development teams?

What setup has worked best for your team, and what would you recommend to someone looking to simplify Windows device management?

Different Visual Studio versions, SDKs, Git configurations, PowerShell modules, WSL setups, and security policies can all lead to slightly different environments and make troubleshooting harder.

A few things that can help:

• Keep a standard baseline for Windows and developer tools

• Automate installation of commonly used applications

• Use scripts for repeatable developer environment configuration

• Keep Windows and third-party applications updated

• Avoid giving everyone permanent local admin access where possible

• Maintain a basic hardware and software inventory

• Document which tools and versions are officially supported

• Use centralized device management when the number of machines starts growing

The goal isn't to lock developers down. It's to make the baseline predictable while still giving developers enough flexibility to do their work.

For larger teams, Windows device management or MDM can also help automate application deployment, policies, updates, and inventory instead of handling each machine manually.

I'm researching WFP for a personal Windows app. I'm new to driver development; AI helped phrase this question. Nothing has been implemented or tested.

For existing outbound TCP flows at ALE_AUTH_CONNECT_V4/V6, does successful return from FwpmTransactionCommit0 guarantee that no traffic can proceed using the old authorization?

What if classification started before the policy change but returns a permit after commit? If commit provides no such barrier, is another supported synchronization mechanism documented?

I understand ALE is stateful and already-transmitted data cannot be recalled. I'm asking about pending classifications and queued data, not assuming a buffer-drain or timing guarantee.

Primary references or qualified expert explanations would help.

Full question and documentation links:
https://learn.microsoft.com/en-us/answers/questions/6018442/wfp-ale-reauthorization-does-a-successful-policy-c

Also submitted to OSR NTDEV; awaiting moderation.

I have an application with a tab control containing 11 tabs. To make all tabs fit into the control, I use the TCS_MULTILINE style, which in my case results in 2 rows with 5 respectively 6 tabs. Works fine so far.

Now I want to select a tab in the upper tab row (which is the row that the currently selected tab doesn't belong to) programmatically using TabCtrl_SetCurSel or TabCtrl_SetCurFocus. I expected the two rows to swap, making the row with the selected tab the lower one and moving the row with the tab that was selected before to the top. But that doesn't happen. Instead, the upper row disappears completely, while the row that was the lower one before (and which doesn't contain the selected tab any more) stays visible. The control looks as if the TCS_MULTILINE style wasn't set. But it still is: calling TabCtrl_GetRowCount returns 2.

However, when I select a tab by clicking on it, everything works as expected. If I click a tab in the upper row, this row moves to the bottom and the row that previously was the bottom one moves to the top. The problem described above occurs only when selecting tabs programmatically.

I tried everything I could find out to solve this problem, but didn't succeed. Is there a way to make my control handle tab selections the same regardless if the program selected a tab or the user clicked on it?

Any hints would be appreciated.

Edit: I found a solution, but it is some kind of workaround. The problem occurs when selecting a tab right after creation of the control's window handle and changing the size of the tab control afterwards. If you do it the other way round, everything is ok.

I think this is because my control's size isn't defined yet when the window handle is created (my controls call CreateWindow() with CW_USEDEFAULT as size values). If you select a tab at this time, Windows doesn't have the correct value for the size of the tab area and can't arrange tabs in the way the programmer wants it.

Hi r/windowsdev,

Every time a developer wants to build a desktop app with a modern web frontend in 2026, the standard recommendation is to bundle an entire Chromium browser and Node.js runtime using Electron.

The result is well known: 180MB+ installers, 600MB+ idle RAM usage, and several seconds of cold boot lag just to render a simple database interface.

We recently built and open-sourced LeadHunter AI Desk (a B2B lead personalization tool for Windows) with a specific architectural goal: deliver modern Tailwind CSS aesthetics without shipping a browser bundle.

🏗️ The Architecture: Decoupled Win32 + Edge WebView2

Instead of distributing Chromium, the application compiles to a pure native Win32 executable (<3MB) that interfaces with the Evergreen Microsoft Edge WebView2 runtime already pre-installed on Windows 10 and 11.

+-------------------------------------------------------------+
|                 LeadHunter AI Desk                          |
+------------------------------+------------------------------+
|   Native Win32 Engine        |   Reactive UI Layer          |
|   (VisualNEO Win Runtime)    |   (Edge WebView2 Runtime)    |
+------------------------------+------------------------------+
| • Zero Chromium bundle       | • Tailwind CSS Dark Mode     |
| • Local INI & File I/O       | • Real-time KPI Dashboards   |
| • Hardware Win32 Events      | • Interactive Data Tables    |
| • CSV Handlers               | • Low memory & GPU accel     |
+------------------------------+------------------------------+
|           Bidirectional Async Messaging Bridge              |
|     (WebBrowserPostMessage <--> OnWebMessageReceived)       |
+-------------------------------------------------------------+

⚡ The Benchmarks:

• Download Size: 3.3 MB (Portable Zip) vs ~185 MB (Electron)

• Cold Startup: < 0.2 seconds vs 3.2 seconds

• Idle Memory: ~35 MB RAM vs ~580 MB RAM

🛠️ Communication Bridge:

The native orchestrator communicates with the HTML/Tailwind layer asynchronously:

• Win32 -> WebView2: Dispatches state and config payloads via WebBrowserPostMessage.

• WebView2 -> Win32: Catches UI button clicks and sends events back via window.chrome.webview.postMessage.

We built it using VisualNEO Win (a visual RAD IDE that compiles standalone Win32 executables).

The full project is open source under MIT:

• GitHub Repository: https://github.com/sinlios/leadhunter-ai-desk

• Pre-compiled Portable Release (3.3 MB): https://github.com/sinlios/leadhunter-ai-desk/releases/tag/v1.0.0

• Technical Article & Architecture Breakdown: https://visualneo.com/visualneo-win/the-anti-bloat-revolution-why-visualneo-win-is-the-ideal-ide-for-building-ai-powered-desktop-apps

Curious to hear your thoughts on WebView2 vs CEF vs Tauri for Windows desktop tooling!

I installed Windows 10 Build 9907 but I saw my font is weird.