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.

Total issues to v1.7.8: 17

Selected for this week: 3

Issue #1: Missing tests, discussions, packaging

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

Free, open source, portable .exe

Windows 10/11

Process library:

JSON format (easy to extend)

MIT license

Contributions welcome

, 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.