A fast, private, cross-platform task manager and system monitor for Windows and Linux. It shows what your computer is doing in real time (processes, CPU, memory, storage and network) and lets you safely end, suspend or reprioritize processes.
Built with Tauri 2, Rust and React. All monitoring stays on your machine: no telemetry, no network access, works fully offline.
Screenshots are not committed because they reveal the host's process list,
hostname and network addresses. To add some, capture them on a clean demo
machine (or with Mock processes enabled in a development build: System
Information → Monitoring diagnostics) and place them in docs/screenshots/.
Windows feature parity with the linux-port branch, including platform limits
and validation, is documented in docs/WINDOWS_FEATURE_PARITY.md.
-
Inspection tools: global ports and port-owner search, file-user lookup, modules, memory maps, threads and a Diagnose Process tab.
-
Applications and activity: expandable application groups, new-process highlights, a bounded event timeline and potential memory/thread growth hints.
-
Startup and system details: reversible Windows Run/Startup-folder controls, richer hardware sections, optional live GPU/sensor readings and saved view choices.
-
Overview: CPU, memory, storage, network and system cards with live 60-second graphs.
-
Processes: virtualized table that stays fast with thousands of processes.
- Instant search by name, PID, command line, executable or user.
- Filter presets: high CPU, high memory, my/system processes, suspended, recently started, long running, heavy disk I/O.
- Sortable, resizable, show/hide columns; optional heat mapping; compact mode.
- Tree view with expand/collapse, safe against PID reuse.
- Keyboard navigation.
-
Process details: general info, CPU/memory/disk history, working directory, architecture, child processes and TCP/UDP connections.
-
Process control:
- End, force end, suspend, resume, change priority, copy details, open file location.
- Confirmation dialogs with escalating warnings.
- Server-side protection for critical system processes and for Task Manager itself.
-
Performance: large CPU, memory, disk and network graphs over 60 s / 5 min / 15 min / 1 h.
-
Memory diagnostics: use Explain usage on Overview or open Memory to rank app/executable groups by RAM or recent growth, inspect individual processes, and understand cache, commit pressure and Windows kernel pools.
-
CPU, Memory, Storage, Network pages:
- per-core graphs;
- cache and commit charge;
- disk IOPS and active time;
- per-interface rates and addresses.
-
Benchmarks: CPU (single/multi-core integer, floating point, SHA-256, LZ4), GPU (wgpu compute and memory), storage (sequential, random 4K IOPS and latency, direct I/O) and an optional internet quality test (download, upload, idle and loaded latency, jitter). Statistics with variation and stability, versioned scores, local history, comparison, trends and export. See docs/BENCHMARKS.md.
-
Alerts: rules such as "node CPU above 80% for 20 s" or "memory above 85%", evaluated in the background with desktop notifications.
-
Settings: theme (system/light/dark), refresh interval (500 ms – 5 s or paused), history length, start with the OS, minimize to tray, launch minimized, remember window position, debug logging.
-
System tray with live CPU/RAM summary and pause/resume.
-
Export: process list as CSV/JSON (command lines opt-in), system summary, diagnostics bundle.
-
Keyboard:
Shortcut Action Ctrl/Cmd+F Search processes Ctrl/Cmd+R Refresh Space Pause/resume monitoring Delete End selected process, after confirmation Ctrl/Cmd+K Command palette Esc Close dialogs
| OS | Status |
|---|---|
| Windows 11 (x64) | Supported (primary) |
| Debian / Ubuntu and other mainstream Linux | Supported |
| macOS | Not yet; the architecture has a platform slot for it |
Platform differences are documented in docs/PLATFORM_SUPPORT.md.
| Layer | Choice |
|---|---|
| Desktop shell | Tauri 2 |
| Backend | Rust (2024 edition), sysinfo, windows crate, libc |
| Frontend | React 19, TypeScript 6 (strict), Vite 8 |
| UI | Tailwind CSS 4, Radix primitives, Lucide icons |
| State | Zustand |
| Charts | uPlot (canvas) |
| Tables | TanStack Virtual |
| Tests | cargo test, Vitest, React Testing Library |
Prerequisites:
-
Node.js 20+ (developed with 24).
-
Rust stable (1.90+), via rustup.
-
Windows: Microsoft C++ Build Tools ("Desktop development with C++") and the WebView2 runtime, which ships with Windows 11.
-
Linux:
sudo apt install libwebkit2gtk-4.1-dev build-essential curl wget file \ libxdo-dev libssl-dev libayatana-appindicator3-dev librsvg2-dev
Run in development:
npm install
npm run tauri devnpm run tauri build| Platform | Output (src-tauri/target/release/bundle/) |
|---|---|
| Windows | msi/ (WiX) and nsis/ (per-user installer) |
| Linux | deb/, rpm/ and appimage/ |
Build each platform on that platform; CI builds both. To build only the
executable, without installers: npx tauri build --no-bundle.
npm run typecheck # TypeScript (strict)
npm run lint # ESLint
npm run format:check # Prettier
npm test # Vitest + React Testing Library
npm run check:linux # type-check and lint Linux Rust code (needs: rustup target add x86_64-unknown-linux-gnu)
npm run check:all # everything above plus cargo fmt, clippy -D warnings and cargo test
npm run gen:types # regenerate TypeScript types from Rust modelsRust tests include integration tests against the real OS:
- the engine produces valid snapshots;
- a spawned child process is suspended, resumed and killed;
- this test process's sockets, architecture and disks are read.
They never touch processes they did not start.
OS ──► tm-core (Rust, no UI dependency)
platform/{windows,linux,macos} ─► monitoring engine (one thread)
├─ alerts, history, process control
└─ TickSink ──► Tauri Channel ──► React stores ──► views
src-tauri/core: models, monitoring engine, platform layer, process control and export. Testable on its own.src-tauri/src: Tauri wiring, typed commands, tray, settings file, logging.src: React app.services/talk to the backend,stores/hold state, andfeatures/contain one folder per page with pure, tested logic.
See docs/ARCHITECTURE.md and docs/MONITORING.md.
- Process control runs through native APIs only, with no shell and no generic command execution.
- Every PID is validated and re-checked against its start time, so a reused PID is never acted on.
- Protection rules run in Rust on every request. The UI cannot bypass them.
- The app is unprivileged. It never elevates itself; denied operations say so clearly.
- Tauri capabilities are limited to
core:default. Plugins are used from Rust only. - Command lines are never logged, and are excluded from exports unless you opt in.
- No telemetry. The only network access is the optional, user-started internet benchmark (privacy notice and consent first).
Details: docs/SECURITY.md.
Measured on a 12-thread laptop with ~240 processes:
- About 1.3% total CPU with the window visible, and 0.1% when minimized.
- The Rust backend uses 18 MB.
- WebView2 adds roughly 200 MB, as it does for any WebView2 app.
Details and methodology: docs/PERFORMANCE.md.
- Read docs/ARCHITECTURE.md.
- Keep OS-specific code in
src-tauri/core/src/platform/<os>, and add a stub for every other OS. - Put logic in pure, tested functions; keep components thin.
- Never report invented values. Use
null/ "Unavailable on this platform". - Run
npm run check:all(andnpm run check:linuxfor platform code) before opening a pull request.
The roadmap is in docs/ROADMAP.md.
- On Windows without administrator rights, protected processes show memory but not CPU, I/O, owner or command line. These are labelled as unavailable, never shown as 0.
- Windows reports the nominal CPU frequency; Linux reports the current one.
- Graceful "End process" on Windows asks the process's windows to close. Windowless processes need "Force end".
- Load average and buffers exist only on Linux; commit charge only on Windows.
MIT