Nobody needs another AI feature.
They need to know if svchost.exe is safe or a virus.
I spent Easter weekend building something embarrassingly simple: a JSON file that explains what 80+ Windows processes actually do.
Not machine learning. Not blockchain integration. Not "AI-powered insights."
Just context.
And it works better than I expected.
The Problem: Task Manager Shows Data, Not Understanding
Open Task Manager right now. You'll see:
svchost.exe — 6 instances, 800MB RAM
dwm.exe — 40% CPU spike
RuntimeBroker.exe — Random activity
System — Always at the top
What do you do?
Google "is svchost.exe a virus?"
Read 10 forum threads.
Still not sure.
Maybe kill the process.
Break something.
PC_Workman now solves this in 0.5 seconds:
Hover on svchost.exe in the chat →
Service Host Process
Microsoft Corporation
Hosts Windows services. Multiple instances are normal.
Power: Low-Medium
Safety: Safe (part of Windows)
CPU: 1-15% per instance
RAM: 50-200MB per instance
Done.
No Google. No paranoia. Just facts.
Easter Weekend: From "Too Tired" to "Shipped"
Context:
Week 1 at Żabka retail: 5:30 AM starts, solo store shifts by day 5, 20 zł/h (~$5/hour).
Monday plan: Process library + timestamps + 2 articles
Tuesday-Friday reality: Too exhausted to code after 9-hour shifts
Saturday-Sunday: Redemption arc
What shipped:
process_library.json — 80+ process definitions
process_library.py — Loader with lookups
tooltip.py — Hover UI widget
Integration in panel.py — Regex binding for chat
Time: ~4 hours total
Difficulty: Medium (Tkinter events + regex)
Impact: HIGH (users finally understand what processes are)
What I Built: The Process Library System
File 1: process_library.json (The Data)
Location: PC_Workman_HCK/data/process_library.json
Size: 80+ definitions (will grow to 150+)
Categories:
System: explorer.exe, svchost.exe, dwm.exe, csrss.exe
Browsers: chrome.exe, firefox.exe, edge.exe, opera.exe, brave.exe
Gaming: steam.exe, valorant.exe, leagueoflegends.exe, fortnite.exe, minecraft.exe
Development: python.exe, node.exe, code.exe, docker.exe, git.exe
Communication: discord.exe, teams.exe, zoom.exe, slack.exe
Media: spotify.exe, vlc.exe, obs64.exe, photoshop.exe
Productivity: excel.exe, word.exe, notion.exe, outlook.exe
Utilities: 7zfm.exe, winrar.exe, everything.exe
Virtualization: vmware.exe, virtualbox.exe
Structure:
json{
"chrome.exe": {
"name": "Google Chrome",
"vendor": "Google LLC",
"category": "browser",
"description": "Web browser. RAM usage increases with open tabs.",
"power_usage": "high",
"safety": "safe",
"typical_cpu": "5-25%",
"typical_ram": "200-800MB per window"
},
"svchost.exe": {
"name": "Service Host Process",
"vendor": "Microsoft Corporation",
"category": "system",
"description": "Hosts Windows services. Multiple instances are normal.",
"power_usage": "low_medium",
"safety": "safe",
"typical_cpu": "1-15% per instance",
"typical_ram": "50-200MB per instance"
}
}
No AI-generated descriptions. All written in plain English, human-verified.
File 2: process_library.py (The Loader)
Location: PC_Workman_HCK/hck_gpt/process_library.py
What it does:
Loads JSON on startup
Provides case-insensitive lookups
Formats tooltip text for display
Implementation:
pythonclass ProcessLibrary:
` """Loads process definitions from JSON and provides lookups"""
def __init__(self):
self.processes = {}
self._load_library()
def _load_library(self):
"""Load process_library.json"""
lib_path = os.path.join(
os.path.dirname(__file__),
'..',
'data',
'process_library.json'
)
if os.path.exists(lib_path):
with open(lib_path, 'r', encoding='utf-8') as f:
self.processes = json.load(f)
print(f"[ProcessLibrary] Loaded {len(self.processes)} process definitions")
def get_process_info(self, process_name):
"""Case-insensitive lookup"""
return self.processes.get(process_name.lower().strip())
def format_tooltip_text(self, process_name):
"""Format for display"""
info = self.get_process_info(process_name)
if not info:
return None
return f"""📦 {info['name']}
{info['vendor']}
{info['description']}
Power: {info['power_usage']}
Safety: {info['safety']}
CPU: {info['typical_cpu']}
RAM: {info['typical_ram']}"""
Singleton instance
process_library = ProcessLibrary()`
Why singleton? One load at startup, shared across all components.
File 3: tooltip.py (The UI Widget)
Location: PC_Workman_HCK/hck_gpt/tooltip.py
What it does:
Creates borderless tooltip window
Positions near mouse cursor
Displays formatted process information
Auto-hides on mouse leave
Implementation:
pythonclass ProcessTooltip:
` """Shows tooltip on hover over process names"""
def __init__(self, parent):
self.parent = parent
self.tooltip_window = None
def show(self, event, process_name, tooltip_text):
"""Show tooltip at mouse position"""
if not tooltip_text:
return
self.hide() # Destroy old tooltip
# Create borderless window
self.tooltip_window = tk.Toplevel(self.parent)
self.tooltip_window.wm_overrideredirect(True)
self.tooltip_window.wm_attributes("-topmost", True)
# Position near mouse
x = event.x_root + 20
y = event.y_root + 10
self.tooltip_window.wm_geometry(f"+{x}+{y}")
# Styled frame + label
frame = tk.Frame(
self.tooltip_window,
bg=THEME["bg_panel"],
highlightbackground=THEME["accent2"],
highlightthickness=2,
padx=12,
pady=8
)
frame.pack()
label = tk.Label(
frame,
text=tooltip_text,
bg=THEME["bg_panel"],
fg=THEME["text"],
font=("Consolas", 9),
justify="left"
)
label.pack()
def hide(self):
"""Destroy tooltip"""
if self.tooltip_window:
self.tooltip_window.destroy()
self.tooltip_window = None`
Positioning logic: +20px right, +10px down from cursor to avoid blocking text.
File 4: panel.py (The Integration)
Location: PC_Workman_HCK/hck_gpt/panel.py
What changed:
Import process library:
`
pythonimport re
try:
from hck_gpt.process_library import process_library
from hck_gpt.tooltip import ProcessTooltip
HAS_PROCESS_LIBRARY = True
except ImportError:
HAS_PROCESS_LIBRARY = False
print("[hck_GPT] Process library not available")
Initialize tooltip in init:
python# Tooltip system
self.tooltip = ProcessTooltip(parent) if HAS_PROCESS_LIBRARY else None
Bind tooltips method:
pythondef _bind_process_tooltips(self):
"""Scan chat text for process names and bind hover events"""
if not HAS_PROCESS_LIBRARY or not self.tooltip:
return
# Get all text
content = self.log.get("1.0", "end-1c")
# Search for .exe patterns
exe_pattern = r'\b\w+\.exe\b'
for match in re.finditer(exe_pattern, content, re.IGNORECASE):
process_name = match.group(0)
# Check if process exists in library
info = process_library.get_process_info(process_name)
if info:
# Create unique tag
tag_name = f"process_{process_name}_{match.start()}"
# Add tag to text
# (Tkinter text index conversion logic here)
self.log.tag_add(tag_name, start_pos, end_pos)
# Style the tag (underline, color)
self.log.tag_config(
tag_name,
foreground=THEME["accent2"],
underline=True
)
# Bind hover events
tooltip_text = process_library.format_tooltip_text(process_name)
self.log.tag_bind(
tag_name,
"<Enter>",
lambda e, pn=process_name, tt=tooltip_text:
self.tooltip.show(e, pn, tt)
)
self.log.tag_bind(
tag_name,
"<Leave>",
lambda e: self.tooltip.hide()
)
Call after adding messages:
pythondef add_message(self, msg):
# ... add text to chat
self._bind_process_tooltips() # Scan and bind`
Regex pattern: r'\b\w+.exe\b' matches word boundaries + .exe extension (case-insensitive)
Why unique tags? Same process can appear multiple times in chat — each occurrence needs separate hover binding.
Why This Matters
Before process library:
User: "epicgames.exe is using 40% CPU — is that normal?"
Action: Google → Reddit → forum threads → paranoia → maybe kill process
After process library:
User hovers on epicgames.exe
Epic Games Launcher
Epic Games, Inc.
Game distribution platform. Updates games in background.
Power: Medium-High
Safety: Safe
CPU: 10-40% (during updates)
RAM: 300-800MB
User: "Oh, it's updating games. That's fine."
Result: Informed decision instead of guessing.
This Week's Plan: 3 Issues from Roadmap 1.7.8
Full roadmap: https://github.com/users/HuckleR2003/projects/3/views/2?pane=issue&itemId=166508113&issue=HuckleR2003%7CPC_Workman_HCK%7C17
Total issues to v1.7.8: 17
Selected for this week: 3
Issue #1: Missing tests, discussions, packaging
Source: GitHub issue from Mary-devz (community feedback)
Problem:
No automated tests yet
Need discussion about update mechanisms
Packaging strategy unclear
Plan:
Set up pytest framework
Create test suite for core modules
Discuss auto-update vs manual download strategy
Define packaging requirements for Microsoft Store
Why this matters: Community feedback = roadmap priorities
Issue #2: [UI] Main dashboard button graphics redesign
Source: Own issue
Problem:
Current buttons functional but inconsistent
Need final visual style before Store submission
Button states (normal/hover/active) need polish
Plan:
Finalize button style guide
Redesign primary controls (Start Monitoring, Settings, Reports)
Implement hover animations
Ensure accessibility (contrast ratios, click targets)
Why this matters: UI = first impression for new users
Issue #3: [Code] Optimize hck_gpt/ modules
Source: Own issue
Problem:
Multiple small files in hck_gpt/ folder
Some code duplication
Performance could be better
Plan:
Analyze module dependencies
Consolidate related functionality
Remove duplicate code
Profile performance bottlenecks
Document optimization decisions
Why this matters: Clean code = easier maintenance = faster feature development
Build-in-Public Philosophy
Why share the struggle?
Because "I planned X, did Y" is more valuable than "look at my perfect progress."
Week 1 reality:
Monday: Ambitious plan
Tuesday-Friday: Too tired after Żabka
Saturday-Sunday: Catch-up sprint
Monday: Selective focus on 3 issues
Not shipping everything. Shipping what matters.
The gap between plan and execution = the actual content.
Current State & Goals
Today:
Day job: Żabka retail (20 zł/h, 1-2 months bridge)
Dev time: Weekends + evenings when possible
PC_Workman: v1.7.0 (process library shipped)
This week:
Close 3 issues from roadmap
Build momentum toward v1.7.8
April target:
v1.7.8 feature-complete
All critical issues resolved
Q3 2026:
Microsoft Store submission
Public release v2.0
June-July 2026:
Exit Żabka → Junior dev role
What's Next
Process library expansion:
Target: 150+ definitions by v1.7.8
Community contributions (submit PRs with process definitions)
Auto-categorization for unknown processes (future)
This week deliverables:
Test framework setup + initial tests
UI button redesign completed
hck_gpt/ optimization documented
Long-term vision:
Microsoft Store release
Cross-platform support (Linux, macOS)
Process behavior learning (detect unusual patterns)
Try It Yourself
PC_Workman v1.7.0:
GitHub: https://github.com/HuckleR2003/PC_Workman_HCK
Free, open source, portable .exe
Windows 10/11
Process library:
JSON format (easy to extend)
MIT license
Contributions welcome
GitHub, here :)
All my links here :)
About the Author
I’m Marcin Firmuga. Solo developer and founder of HCK_Labs.
I created PC Workman , an open-source, AI-powered
PC resource monitor
built entirely from scratch on dying hardware during warehouse
shifts in the Netherlands.
This is the first time I’ve given one of my projects a real, dedicated home.
Before this: game translations, PC technician internships, warehouse operations in multiple countries, and countless failed projects I never finished.
But this one? This one stuck.
800+ hours of code. 4 complete UI rebuilds. 16,000 lines deleted.
3 AM all-nighters. Energy drinks and toast.
And finally, an app I wouldn’t close in 5 seconds.
That’s the difference between building and shipping.
PC_Workman is the result.
Top comments (0)