Pulse

Pulse is a Windows-first desktop diagnostics utility built with Tauri 2, Rust, React, and TypeScript.

It is designed to answer a simple question quickly: why does the laptop suddenly feel hot, noisy, slow, or battery-hungry? Instead of exposing a wall of raw telemetry, Pulse turns low-overhead system samples into a compact diagnosis-oriented UI.

What Problem Pulse Solves

Most system monitors are optimized for people who already know how to interpret temperature graphs, process lists, and dozens of hardware counters.

Pulse takes a narrower product approach:

• detect when the machine feels meaningfully stressed
• summarize current system state in a compact always-available widget
• explain likely causes in plain language
• show a short recent timeline instead of a giant dashboard
• keep the compact view calm and glanceable rather than turning into a mini Task Manager

UI Model

Pulse currently has three layers:

1. Compact widget A small bottom-right desktop widget that stays visible and shows the current state plus a few key vitals.
2. Expanded panel The same widget window can expand vertically to show the likely cause, a compact metrics strip, recent changes, and a top process summary.
3. Full details window A separate secondary window for the full Overview, Timeline, and Offenders views.

The compact widget is the primary experience. The details window is intentionally secondary.

Compact Widget Design Intent

The compact widget is meant to feel like a restrained desktop companion, not a noisy process monitor.

The collapsed widget prioritizes:

• current system state
• CPU usage
• RAM usage
• temperature only when thermal support actually exists
• a subtle live accent for severity

It intentionally does not surface top offender process details in the compact state, because that makes the product feel more like Task Manager than a diagnosis utility.

What the App Shows

Compact widget

• current system state
• CPU usage
• RAM usage
• CPU temperature when supported

Expanded panel

• state header
• likely cause summary
• compact metrics strip
• recent changes
• top process summary
• link to open full details

Full details window

• Overview
• Timeline
• Offenders

Metrics and Unsupported Data

Pulse tries to stay honest about Windows telemetry limitations.

Currently supported or commonly available:

• CPU load
• RAM pressure
• average CPU clock trend
• battery percentage
• battery state and rate when available
• recent process offender summaries

Conditionally available:

• CPU temperature
• GPU temperature

If a metric is not reliably available on the current machine, Pulse does not pretend otherwise. Unsupported temperature data is omitted or shown as unavailable in the larger views, rather than presented with fake certainty.

Current Feature Set

Implemented today:

• widget-first Tauri desktop shell
• bottom-right always-on-top compact widget
• expanded widget panel
• separate full details window
• Rust-owned sampling loop
• heuristic state classification
• recent event generation
• plain-English explanation generation
• SQLite-backed local persistence
• tray integration
• pause/resume monitoring flow
• single-instance details window behavior

Public Release Scope

This repository is being published as a serious portfolio project, not as a finished commercial product.

That means:

• the architecture is real
• the UI is intentionally designed
• the diagnostic framing is deliberate
• some hardware data remains limited by Windows sensor availability
• unsupported capabilities are not exaggerated in the documentation

Tech Stack

Languages

• Rust
• TypeScript
• TSX
• CSS
• SQL via SQLite
• JSON
• TOML

Frontend

• React 18
• Vite 5
• Zustand
• @tauri-apps/api

Backend

• Rust 2021 edition
• Tauri 2
• Tokio
• Serde
• Serde JSON
• Chrono
• Rusqlite
• Sysinfo
• Windows crate

Tauri plugins

• tauri-plugin-single-instance
• tauri-plugin-autostart

Platform Requirements

Current support target:

• Windows

This project is designed and implemented as a Windows-first desktop app. The monitoring logic, tray behavior, and sensor integrations are not presented as cross-platform.

Architecture

Pulse keeps the system-facing logic in Rust and the rendering logic in React.

Rust backend owns

• system sampling
• sensor abstraction layer
• rolling windows and cadence control
• state classification
• explanation generation
• event generation
• SQLite persistence
• tray behavior
• window creation/focus behavior
• monitoring pause/resume state
• Tauri commands and event emission

React frontend owns

• widget rendering
• expanded panel rendering
• details window rendering
• navigation between Overview / Timeline / Offenders
• formatting and presentation of backend-authored DTOs

Project Structure

src/
  app/
    App.tsx
    store.ts
  components/
    Sidebar.tsx
  features/
    widget/WidgetView.tsx
    overview/OverviewView.tsx
    timeline/TimelineView.tsx
    processes/OffendersView.tsx
  hooks/
    useWidgetWindow.ts
  lib/
    format.ts
    pulse.ts
    types.ts
  styles/
    index.css
  main.tsx

src-tauri/
  src/
    main.rs
    app_state.rs
    commands/
    detection/
    events/
    sampling/
    sensors/
    storage/
    tray/
  Cargo.toml
  tauri.conf.json
  capabilities/

Sensor and Detection Design

Pulse is not a raw telemetry mirror.

The app samples system state, maintains a rolling window, and turns those samples into a higher-level diagnosis model:

• primary system state
• battery state
• performance pressure
• recent notable events
• likely explanation

The goal is to help a user answer "what changed?" rather than forcing them to inspect a full monitoring dashboard.

Running the Project

Prerequisites

• Node.js and npm
• Rust toolchain
• Tauri build prerequisites for Windows
• Microsoft WebView2 runtime

Install dependencies

npm install

Run in development

npm run tauri:dev

Build a production package

npm run tauri:build

Notes for Windows Development

Depending on the machine, you may also need:

• Visual Studio Build Tools with C++ support
• WebView2 runtime
• standard Rust MSVC toolchain support

Important Engineering Decisions

1. Widget-first instead of dashboard-first

Pulse starts from a compact desktop widget because the main interaction is meant to be glanceable.

2. Rust owns system logic

Sampling, detection, and persistence live in Rust so system-facing behavior stays centralized and the frontend only renders structured state.

3. Honest handling of unavailable telemetry

Temperature support is conditional. The app does not fabricate thermal confidence on machines where Windows does not expose reliable data.

4. Low-overhead intent

Pulse is structured around configurable sampling cadence and rolling heuristics so the monitor itself does not become the problem.

5. Details window stays secondary

The app supports deeper inspection, but the primary interaction remains the compact widget and expanded panel.

Limitations

Current limitations that matter for a public reader:

• Windows-only target in its current form
• thermal telemetry is hardware- and API-dependent
• GPU usage is not exposed as a first-class compact-widget metric today
• settings UX is still lighter than the monitoring core
• this is a local desktop utility, not a cloud-backed monitoring platform

Repo Cleanup Notes

This public-facing pass removes generated and machine-local artifacts such as:

• dependency folders
• local npm cache
• local Rust toolchain/cache folders
• build outputs
• installer artifacts
• temp logs
• machine-specific bootstrap files

Those files are intentionally excluded from the repository so the public repo stays clean and safe to inspect.

Why This Repo Exists

This project is meant to demonstrate product thinking and implementation quality across:

• desktop UX
• systems-oriented Rust architecture
• frontend restraint and information hierarchy
• honest platform-specific engineering tradeoffs
• turning raw system samples into a clear diagnosis-oriented experience