HPR vs. the field.
An honest comparison. HPR needs users, so every claim here is verifiable and every gap is acknowledged.
Head to head.
Four trackers, compared honestly. HPR's strengths and gaps, side by side.
| Feature | HPR | ActivityWatch | RescueTime | Toggl |
|---|---|---|---|---|
| Binary Size | ~4-5 MB | 200 MB+ | Cloud app | Cloud app |
| RAM (Real) | ~13 MB Win / ~26 MB Linux | 200 MB+ | N/A | N/A |
| Account Required | No | No | Yes | Yes |
| Data Leaves Machine | Never (unless opted-in) | Never | Yes | Yes |
| Automatic Tracking | Yes | Yes | Yes | No |
| Native Wayland | Yes | Partial | N/A | N/A |
| Embedded Web Server | No | Yes | No | No |
| Open Source | Yes | Yes | No | No |
| Launch Time | Instant | Several seconds | N/A | N/A |
| Free | Yes | Yes | Limited | Limited |
| Runtime UI Editing | Interpreted Mode | No | No | No |
| Browser Tab Tracking | Built-in, no extension Tab View (raw) + Site View (formatted) |
Optional extension | Required extension | Optional extension |
| VS Code Project Tracking | Built-in, no extension Raw View + Formatted View toggle |
Via plugin | No | No |
| Sandboxed Lua Extensions | Yes (Lua 5.4 Sandbox) | Varies (Unisolated Plugins) | No | No |
| Hot-Reload UI | Yes ("Reload UI" button) | No | No | No |
| Hot-Reload Extensions | Yes (Live VM Swap) | Manual Process Restart | No | No |
| Per-App Limits & Goals | Yes (with notifications) | No | Limits only (premium) | No |
| Multi-Day Historical Queries | Yes (Range / Last N Days) | Web dashboard only | No | No |
| Day Construction Timeline | Yes (Zoom/Scroll, Hover, & Gap Capping) | Static horizontal timeline (often fiddly) | No | No |
| Advanced Pattern Analysis | Yes (9 localized offline metrics) | Basic statistics & custom queries | No | No |
HPR vs. ActivityWatch
ActivityWatch is the most honest comparison. It's a mature, maintained project with years of production use. Here's where they genuinely differ.
Where HPR leads
A fraction of the memory footprint. Native Wayland from day one across five desktop environments. No Python runtime. No embedded web server running in the background. Starts instantly.
Day Construction Timeline — Reconstructs your daily transition log chronologically onto an interactive canvas. Unlike ActivityWatch's default horizontal visualization which can feel fiddly to zoom and scale, HPR offers built-in zoom presets (1h, 3h, 8h, 24h, All Day) and adaptive markers. More importantly, HPR's timeline reconstruction engine features continuity gap capping (restricting segment lengths to a maximum of 1 minute when transitioning to an Unknown state), ensuring reboots or system downtime don't visually stretch active applications across focus gaps.
Advanced Cross-Day Insights — Computes 9 advanced offline correlation metrics (Escape Pattern rate, distraction Return Rate, Average Focus Session duration, weekly Focus Dip Hours, morning Deep Work ratios, and Weekend vs Weekday habits) directly on localized daily database files using parallel database queries, rather than relying on heavy client-server web queries.
Per-App Limits & Goals — Set a daily usage cap or daily usage goal on any tracked application from a built-in UI. A dedicated background thread monitors usage and fires system notifications when thresholds are crossed. ActivityWatch has no equivalent built-in system.
Sandboxed Lua Extension Engine — Dynamic scriptable extension platform using a fast, secure, thread-safe Lua sandbox integrated directly with C++ handles, the EventHub, and SQLite queries. The API is beginner-friendly — drop a .lua file, write a function, and you're running. Supports live hot-reloading of extensions without restarting. Advanced users can go deeper with the Function Overriding API, intercepting and replacing 28 core C++ engine functions directly from Lua.
Interpreted UI mode — edit the entire interface at runtime inside app-window.slint without recompiling, and trigger an instant hot-reload of the UI with a single press of the "Reload UI" button.
Browser tab tracking and VS Code project tracking with no extensions whatsoever — not optional, not recommended, literally not needed. HPR reads the window title the OS already exposes. Both support toggleable raw and formatted name views built into the app.
Where ActivityWatch leads
Full web dashboard. Browser extensions for detailed URL tracking. Massive pre-built plugin/watcher collection. Years of production stability. Active community and documentation.
If you need something mature and battle-tested today, use ActivityWatch. HPR is for those who value the architecture and can tolerate being early.
Architecture comparison
HPR Architecture
Single binary (C++23) └── Slint UI (native rendering) └── SQLite3 (amalgamation, compiled-in) └── Sandboxed Lua Engine (extensions) └── LimitsManager (background goals/limits) └── N threads, one per loaded extension No web server No Python No Electron No runtime dependencies
ActivityWatch Architecture
Multiple processes (Python + TS) └── aw-server (REST API + web UI) └── aw-watcher-window └── aw-watcher-afk └── Browser extension (optional) Web server always running Python runtime required Multiple processes
Resource footprint
The Wayland question.
Wayland is the present and future of Linux desktops. HPR was designed for it from day one.
HPR: Native Wayland
Dedicated backend for each compositor. No XWayland fallback. No compatibility hacks.
ActivityWatch: Partial
Wayland support varies by compositor. Some configurations require X11 fallback or additional configuration.
What HPR doesn't have yet.
HPR is v0.9.4. These are real gaps that ActivityWatch has filled over years of development.
No Web Dashboard
HPR has a native UI only. No browser-based interface. No REST API for external tools to query.
No Mobile Apps
No iOS or Android companion apps. HPR is strictly focused on desktop tracking environments (Linux, macOS, and Windows).
Smaller Community
HPR is new. Fewer users, fewer bug reports, fewer real-world configurations tested. ActivityWatch has years of battle-testing.
If you need something mature and battle-tested today, use ActivityWatch. If the architecture and footprint appeal to you and you can tolerate being early, HPR is worth following. Both projects are open source and free.
What only HPR does.
Features that don't exist in any other open-source activity tracker.
Interpreted UI Mode
No other tracker lets you edit the entire user interface at runtime. Not CSS themes. Not config-driven colors.
Full Slint language access — layouts, animations, component structure, property bindings. Set use-interpreter,true
and edit app-window.slint. No build step. No recompilation.
Traditional Themes
CSS variables. Color tokens. Maybe font selection. Structure is fixed. Layout is fixed. You get to pick colors.
HPR Interpreted Mode
Full UI runtime. Change layouts. Add components. Modify animations. Restructure the interface. The Slint language, not a subset of it.
Sandboxed Lua Extension Engine
HPR embeds a concurrency-safe, sandboxed sol2-bound Lua 5.4 VM inside its core. No binary compilation required. Extensions run in isolated background threads with built-in native APIs to safely execute SQLite queries, register Slint UI interactive callbacks, query local or remote REST endpoints via HTTP GET/POST, and subscribe to system-wide signals in real-time.
The extension API is designed for beginners — if you can write a simple Lua function, you can extend HPR. No compilation, no framework, no boilerplate. For advanced developers, the Function Overriding API lets you intercept and replace 28 core C++ engine functions directly from Lua — rename windows, mock databases, block notifications, spoof time, hijack HTTP, and more. Override API docs →
Traditional Plugins
Often require compiling binary libraries, installing heavy external runtimes (like Python or Node), or running unisolated processes that can freeze the app or crash your tracker.
HPR Lua Extensions
Thread-safe sandboxing. If an extension crashes, the core continues running unaffected. Clean C++ RAII safety automatically unregisters all EventHub connections upon unloading or reloading.
Browser Tab Tracking — No Extension
Chrome, Edge, Firefox, Brave — tracked per-site and per-tab with zero browser extensions. Toggle between Tab View (raw OS title) and Site View (grouped by domain via tabAliases.csv) inside the app. No hooks. No manifest. No permissions dialog.
Hot-Reloading Aliases
Save the alias file, HPR picks it up on the next tick. Late-binding design means renaming an alias retroactively updates all historical data with zero migration.
Dual-Clock Timing
steady_clock for duration, system_clock for display. Immune to NTP corrections and DST transitions. Measurement and display use different clocks by design.
VS Code Project Tracking — No Extension
Tracks which VS Code project you're in, not just that VS Code is open. No VS Code plugin. No marketplace. Toggle between Raw View (full OS window title substring) and Formatted View (categorizes projects via projectAliases.csv, e.g., to group by client). Works on every supported platform.
Hot-Reloading UI
Edit your entire user interface definition at runtime using HPR's interpreted mode. Modify component layouts, structural themes, bindings, and animations inside app-window.slint, and trigger an instant recompilation and re-render with a single click of the "Reload UI" button without restarting the application.
Hot-Reloading Extensions
Unload, reload, or refresh all background Lua scripts dynamically from HPR's Loaded Extensions manager UI. HPR cleanly terminates active Lua execution threads, resolves and destroys Lua VM instances, and restarts them instantly with fresh code modifications.
Per-App Limits & Goals
Set a daily usage cap or daily usage goal for any tracked app directly from the built-in Goals view. HPR's background monitor thread checks usage continuously and fires system notifications at threshold crossing. No third-party tools. No config files to edit. Works out of the box on all platforms.
Multi-Day Historical Aggregation
Select last N days or a specific date range. HPR spawns parallel background query threads (an N-thread approach), reads multiple daily .db files concurrently, merges the data, and streams results back into the UI without interrupting live tracking. It remains fast and avoids the 30s timeouts common in single-threaded alternatives like ActivityWatch.
Day Construction Timeline
Maps window transitions chronologically onto a scrollable canvas. Includes zoom presets (1h, 3h, 8h, 24h, All Day), adaptive hour spacing, hover micro-interactions, and continuity gap capping (caps segments to 1 min when entering an Unknown state to ignore downtime).
Advanced Pattern Analysis
Extracts 9 advanced cross-day metrics (escape patterns, return rates, average session length, distracted days, productive days, screen time comparisons, focus dip hours, deep work, and weekend grinds) locally on your SQLite database using concurrent multi-thread reads.
Try HPR alongside ActivityWatch.
They track the same thing. Run both, compare the experience. HPR uses ~13 MB on Windows — you won't notice it.