NeoHtop offers a refreshing alternative to traditional Electron-based system monitors by pairing a Rust backend with a SvelteKit frontend under the hood of the Tauri framework. This combination results in a cross-platform desktop app that tracks system processes and resources with a surprisingly low footprint. The project’s architecture and implementation choices bring a clean separation of concerns and practical features like regex filtering and process pinning, making it worth a close look.
What neohtop does and how it’s built
NeoHtop is a cross-platform desktop system monitor designed to replace or complement tools like htop or Activity Monitor. It provides real-time process monitoring, resource usage stats, and process management features such as kill operations and pinning.
The app’s architecture splits clearly between a Rust backend and a SvelteKit frontend, connected through Tauri. Rust handles the system-level tasks — enumerating processes, fetching CPU and memory metrics, and managing OS syscalls. This choice leverages Rust’s memory safety and performance advantages, providing direct access to platform APIs without the overhead of a VM.
On the frontend side, SvelteKit manages the reactive UI components, with CSS variables supporting theming and FontAwesome icons providing a minimal dependency surface. This keeps the UI lightweight and responsive.
Tauri acts as the glue, embedding the SvelteKit app in a native webview rather than bundling a full Chromium browser like Electron does. This significantly reduces binary size and runtime memory usage.
There’s also a related CLI variant written in Go using the Charm terminal UI ecosystem, but NeoHtop’s main focus is the desktop app experience.
The key features include:
- Real-time process tracking with CPU, memory, and thread counts
- Regex-powered search filtering with multi-term support
- Process pinning to keep important processes visible
- Process kill operations directly from the UI
This combination creates a user-friendly system monitor that doesn’t sacrifice performance or footprint.
The technical strength in Tauri’s Rust-SvelteKit hybrid
NeoHtop’s standout technical choice is its use of Tauri to deliver a native desktop experience without Electron’s overhead. Electron apps typically ship with a bundled Chromium browser, inflating binary size to over 150MB and consuming significant RAM even for simple apps.
Tauri instead leverages the operating system’s native webview component, slashing the app size and memory footprint. This is a clear tradeoff: you lose some control over UI rendering consistency across platforms but gain a much lighter app.
Rust shines as the backend language here. System monitoring requires fast, low-level access to process tables and OS metrics, which Rust handles with native bindings and safe concurrency. The backend code is responsible for hot paths like enumerating processes and gathering CPU/memory stats in real time.
Separating this from the UI, which is handled by SvelteKit and TypeScript, improves maintainability and UX responsiveness. SvelteKit’s reactive model means the UI updates seamlessly as new data arrives without heavyweight frameworks or excessive dependencies.
The codebase favors minimal dependencies, using CSS variables for theming and FontAwesome for icons, which keeps the frontend lightweight and stable.
One practical feature worth noting is the regex-based search filter that supports multiple comma-separated terms, letting users easily drill down into running processes.
The tradeoffs are clear:
- Tauri’s native webview approach can sometimes mean slight differences in rendering or feature support compared to Electron’s Chromium.
- Rust backend requires some familiarity for contributors, especially around OS-specific process enumeration.
- The frontend’s use of SvelteKit is modern but less ubiquitous than React or Vue, which might steepen onboarding.
Still, this architecture strikes a solid balance between performance, developer experience, and user experience.
Quick start with neohtop
Prerequisites
- Node.js (v16 or later)
- Rust (latest stable)
- Xcode Command Line Tools (for macOS)
Installation
Manual
Download the latest release from the GitHub releases page.
Package managers
Community-maintained packages exist for multiple platforms but are not officially endorsed:
macOS
brew install --cask neohtop
Arch Linux (AUR)
yay -S neohtop
or
paru -S neohtop
Fedora Linux
dnf install neohtop
Windows
scoop bucket add extras
scoop install extras/neohtop
Solus
eopkg install neohtop
Running with sudo
To monitor processes requiring elevated privileges:
- macOS:
sudo /Applications/NeoHtop.app/Contents/MacOS/NeoHtop - Linux:
pkexec /path/to/neohtop(recommended)
Where neohtop fits and who should consider it
NeoHtop is an interesting pick for developers and system administrators who want a system monitor that feels native and lightweight without sacrificing the features expected from tools like htop.
It’s especially valuable if you want to avoid Electron’s memory and disk overhead but still want a modern UI with reactive updates.
The project’s architecture makes it a good reference if you’re exploring Tauri for your own desktop apps, or if you want to see Rust applied effectively for system-level tasks alongside a modern frontend framework.
Limitations include the need for Rust and SvelteKit familiarity if you want to contribute or extend the code, and some platform-specific quirks in rendering or permissions that come with using native webviews.
Overall, NeoHtop offers a compelling, practical example of how to ship a performant cross-platform desktop app with a clean separation between backend system logic and frontend UI.
Related Articles
- Jan: a local-first desktop app for large language models with Tauri and Rust — Jan is an open-source desktop app that runs large language models locally using Tauri, Node.js, and Rust. It offers priv
- nh: a Rust-based unified CLI for the Nix ecosystem with enhanced search and ergonomics — nh is a Rust CLI tool consolidating Nix, NixOS, and Home Manager commands with improved ergonomics, speed, and Elasticse
- Pydoll: Async-native Chromium automation with typed extraction for web scraping — Pydoll is a Python library for Chromium automation using Chrome DevTools Protocol. It offers async-native APIs and Pydan
- CC Switch: unified management for AI coding CLIs in a cross-platform Rust desktop app — CC Switch is a Rust-based cross-platform desktop app that centralizes management of AI coding CLIs like Claude Code and
→ GitHub Repo: Abdenasser/neohtop ⭐ 8,998 · Svelte