Task Manager

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

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

Features

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

Supported operating systems

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.

Technology

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

Development

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 dev

Building

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

Testing and checks

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 models

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

Architecture

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, and features/ contain one folder per page with pure, tested logic.

See docs/ARCHITECTURE.md and docs/MONITORING.md.

Security model

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

Performance

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.

Contributing

1. Read docs/ARCHITECTURE.md.
2. Keep OS-specific code in src-tauri/core/src/platform/<os>, and add a stub for every other OS.
3. Put logic in pure, tested functions; keep components thin.
4. Never report invented values. Use null / "Unavailable on this platform".
5. Run npm run check:all (and npm run check:linux for platform code) before opening a pull request.

The roadmap is in docs/ROADMAP.md.

Known platform differences

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

License

MIT