DEV Community: VaultSoft

I'm self-taught and just shipped my first real Windows app — here's everything I learned

VaultSoft — Sat, 23 May 2026 00:03:14 +0000

Six weeks ago I didn't know what PyQt6 was.

Today I have two free Windows apps live, listed on
MajorGeeks, Softpedia, SourceForge and AlternativeTo,
with over 100 downloads across both.

This is everything I learned along the way.

Who I am

I'm Josh. Self-taught developer from the UK. No CS
degree, no bootcamp, no formal training.

I learned to code by building things I actually wanted
to exist. That's still how I work.

The problem I wanted to solve

Task Manager has frustrated me for years.

It tells you something is using your CPU. It won't
tell you which core is thermal throttling, whether
your GPU is about to overheat, or which startup
program added 8 seconds to your boot time.

I wanted one clean window showing everything. So I
built it.

App 1 — PulseMonitor

PulseMonitor is a free real-time PC health monitor
for Windows. It shows:

CPU usage per core, clock speed and temperature
GPU load, VRAM and temperature
RAM usage with live history graph
Network upload and download speeds
Drive health across all connected drives
Process manager with End Task
Startup manager — add and remove startup programs
Performance history graphs for 1hr, 24hr and 7 days
Mini gaming overlay — press Ctrl+Shift+M

App 2 — SweptPC

After shipping PulseMonitor I discovered my PC had
14GB of junk it had been hoarding silently.

SweptPC scans your system and shows exactly how much
space each category is using before deleting anything:

Windows temp files
Chrome, Edge and Firefox cache
Teams and Discord cache
Windows Update leftovers
Thumbnail cache
Memory dumps

Scan first, clean what you want. No surprises.

The tech stack

Both apps use the same stack:

Python 3.11 — language I know best
PyQt6 — desktop UI framework
psutil — system metrics
nvidia-smi — NVIDIA GPU data via subprocess
WMI — AMD/Intel GPU and temperature data
SQLite — performance history database
PyInstaller — bundles into standalone EXE

No installer needed. Just extract the ZIP and run.

The hardest problems I solved

1. Animation destroying CPU performance

My first version gave every animated widget its own
60fps QTimer.

On a Ryzen 9 3900X with 24 cores that meant:

24 CoreBar widgets × 60fps
Plus MetricCard, CircleGauge, AnimFloat timers
Total: 1,500+ repaints per second

CPU usage hit 80%+. For a monitoring app.

The fix was a singleton AnimDriver — one shared QTimer
that all widgets register with when animating and
deregister from when done. If nothing is animating
the timer stops entirely.

CPU dropped from 80%+ to under 5% idle.

2. Cross-thread Qt signals

MonitorThread runs in a background thread. You cannot
safely pass Python objects across Qt thread boundaries.

The solution: emit a zero-argument signal from the
thread. The UI reads from a shared snapshot instead
of receiving data directly.

Took me days to figure out. Costs 5 seconds to
implement once you know.

3. Antivirus false positives

Early builds were flagged by Bitdefender because I
was using WinRing0 and LibreHardwareMonitor for
temperature data.

Solution: remove kernel drivers entirely. Use WMI
and nvidia-smi only. Clean bill of health from
every antivirus.

4. PyInstaller packaging

Getting a truly portable EXE — no Python needed,
no dependencies, just extract and run — took several
attempts.

Key lessons:

Use --onedir not --onefile for faster startup
Embed the icon in the spec file not the command line
Test on a clean machine with no Python installed
Add a crash log that writes to %APPDATA% not the temp directory

What happened after launch

I submitted both apps to software directories and
reached out to tech bloggers and YouTubers.

Results after 6 weeks:

27 SourceForge downloads
50+ MajorGeeks downloads
26 Softpedia downloads
124 GitHub clones by 63 unique developers
4.5/5 review on Softpedia
5/5 review on MajorGeeks
Response from NetworkChuck's team (4.6M YouTube subs)
Downloads in USA, UK, Germany and more

Not life changing numbers. But real people using
something I built from scratch.

What I'd do differently

Start marketing earlier. I spent weeks perfecting
the app before telling anyone it existed. Ship sooner,
market sooner.

Submit to directories on day one. Softpedia,
MajorGeeks and SourceForge bring consistent organic
traffic forever. The sooner you're listed the sooner
the downloads start.

Write about what you're building. Every article
brings more people than a week of social media posts.

What's next

Both apps are free and always will be. I'm planning
a freemium v2.0 of PulseMonitor with a Pro tier for
power features.

VaultSoft is my indie brand. The goal is to build a
small suite of genuinely useful free Windows tools
and eventually make it sustainable.

Links

Both apps are free and open source:

🖥️ PulseMonitor — https://vaultsoft.github.io/PulseMonitor

🧹 SweptPC — https://vaultsoft.github.io/SweptPC

Source code — https://github.com/VaultSoft

If you're self-taught and thinking about shipping
something — just start. The gap between "learning
to code" and "shipping real software" is smaller
than you think.

What questions do you have about the build?

The Best Free PC Health Monitor for Windows in 2026 — PulseMonitor

VaultSoft — Fri, 17 Apr 2026 20:48:35 +0000

Building PulseMonitor — what I learned making a Windows PC monitor in Python

I'm a self-taught developer from the UK. A few weeks ago I decided to build a real Windows desktop app from scratch using Python and PyQt6.

This is what I learned.

The problem I was solving

Task Manager is fragmented. HWiNFO is powerful but overwhelming. I wanted one clean window that shows everything important about my PC in real time.

Tech stack I chose

Python 3.11 — language I know best
PyQt6 — surprisingly capable for desktop UI
psutil — cross-platform system metrics
nvidia-smi — subprocess call for NVIDIA GPU data
WMI — Windows Management Instrumentation for AMD/Intel GPU and temperatures
SQLite — local performance history database
PyInstaller — bundles everything into a standalone EXE

The hardest problems I solved

1. Animation performance

My first naive implementation gave every animated widget its own QTimer running at 60fps. With 24 CPU core bars on screen that was 1,500 repaints per second. CPU usage hit 80%+.

The fix: a singleton _AnimDriver class — one shared QTimer that widgets register with when animating. CPU dropped from 80%+ to under 5%.

class _AnimDriver(QObject):
    tick = pyqtSignal()
    _instance = None

    def __init__(self):
        super().__init__()
        self._timer = QTimer()
        self._timer.setInterval(33)  # ~30fps
        self._timer.timeout.connect(self.tick)
        self._count = 0

    def register(self):
        self._count += 1
        if not self._timer.isActive():
            self._timer.start()

    def deregister(self):
        self._count = max(0, self._count - 1)
        if self._count == 0:
            self._timer.stop()

2. Cross-thread Qt signals

MonitorThread runs in a background thread and can't safely pass Python objects to the UI thread. The solution was a zero-argument signal — the thread emits a tick, the UI reads from a shared snapshot:

class MonitorThread(QThread):
    sig_tick = pyqtSignal()  # zero args — no object crossing thread boundary

    def run(self):
        while self._running:
            self._snapshot = self._collect_metrics()
            self.sig_tick.emit()
            time.sleep(self._interval)

3. Supporting AMD and Intel GPUs

nvidia-smi only works for NVIDIA. For AMD and Intel I used WMI's GPU performance counters — the same data source Windows Task Manager uses:

import wmi
w = wmi.WMI(namespace="root\\cimv2")
for item in w.Win32_PerfFormattedData_GPUPerformanceCounters_GPUEngine():
    if "engtype_3D" in item.Name:
        utilization = item.UtilizationPercentage

4. Packaging with PyInstaller

Getting a clean portable EXE with no false positive antivirus flags took several attempts. Key lessons:

Remove any kernel-level drivers (WinRing0, LibreHardwareMonitor) — they trigger antivirus
Use --onedir not --onefile for faster startup
Embed the icon properly in the spec file

What I built

The finished app has 11 pages: Dashboard, CPU, Memory, GPU, Storage, Processes, Startup, Fans, Network, History and Settings.

It uses under 5% CPU idle, runs from a ZIP with no installation, and has an auto-updater built in.

What's next

VaultCleaner — a PC cleanup tool using the same stack
Freemium model once I have enough users

If you're interested in the source code or want to try it:
https://github.com/VaultSoft/PulseMonitor

What would you build differently?

System Requirements

OS: Windows 10 or Windows 11 (64-bit)
RAM: ~50 MB while running
Disk: ~150 MB extracted
GPU temp monitoring: NVIDIA GPU required (AMD GPU support via HWiNFO64 with admin rights)
Admin rights: Optional — required only for CPU temperature on AMD Ryzen processors

How to Run PulseMonitor

Download the ZIP from the link below
Extract it anywhere — Desktop, Downloads, a USB drive, wherever suits you
Run PulseMonitor.exe directly from the extracted folder
Optional: right-click the exe and send a shortcut to your Desktop or pin it to the taskbar

That's it. PulseMonitor is fully portable — no installer, no registry entries, no files scattered across your system. To remove it, delete the folder.

Download PulseMonitor — Free

Stop guessing what your PC is doing. PulseMonitor gives you the full picture in one clean window, monitors in the background when you don't need it, and alerts you before small problems become big ones.

→ Download PulseMonitor Free from Gumroad

Compatible with Windows 10 and Windows 11. No subscription. No account required.

Have a question or found a bug? Reach out at vaultwall@proton.me — feedback directly shapes future versions.