If you’ve built a custom PC recently, you’ve probably looked into putting a 5-inch or 8.8-inch ultra-wide "sensor panel" inside your case. It looks incredible, but the software ecosystem running these displays is a nightmare.

Your options are basically:

Pay $40 for AIDA64, which features a UI that hasn't been updated since 2004, and manually drag the window to your secondary display every time you reboot.

Spend a weekend editing .ini text files in Rainmeter just to get a reliable GPU temperature reading.

I got tired of negotiating with friction. I didn't want to write C++, and I didn't want to pay for legacy bloatware. So, over the weekend, I engineered a bypass using React, Electron, and Node.js.

Here is how I built VibeAxis Telemetry, a 1-click, completely borderless hardware monitor.

The Architecture: Solving the "Dual Window" Problem
The biggest UX problem with desktop widgets is configuration. You want the dashboard to be borderless, locked, and un-clickable. But you still need a way to change themes and upload backgrounds.

I needed two separate windows: a locked Dashboard and a standard Control Panel.

Instead of building and compiling two completely separate React applications, I used a URL Hashing trick inside a single Vite/React build. When Electron spawns the windows, it simply appends a hash to the local file path:

TypeScript
// main.ts (Electron Backend)
function createDashboardWindow() {
dashboardWin = new BrowserWindow({ width: 1280, height: 400, frame: false });
dashboardWin.loadFile('index.html', { hash: 'dashboard' });
}

function createSettingsWindow() {
settingsWin = new BrowserWindow({ width: 600, height: 700 });
settingsWin.loadFile('index.html', { hash: 'settings' });
}
On the React side, a single useEffect hook listens to the URL route. If it sees /#dashboard, it renders the SVG dials. If it sees /#settings, it renders the buttons and file upload inputs. One codebase, two completely decoupled UIs.

The IPC Bridge: Talking Across the Void
Because the two windows are separate Chromium processes, they can't share a React state. If a user uploads a new background image in the Settings window, I need to instantly beam that image to the Dashboard.

I built a secure IPC (Inter-Process Communication) bridge using Electron's contextBridge.

When you upload an image in the Settings window, React converts the file into a Base64 string and fires it across the bridge to the Node backend:

JavaScript
// App.jsx (Settings Window)
const handleImageUpload = (e) => {
const reader = new FileReader();
reader.onload = (event) => window.api.sendBg(event.target.result);
reader.readAsDataURL(e.target.files[0]);
}
The Node backend catches it, acts as a relay station, and blasts it directly into the isolated Dashboard window, updating the CSS instantly without a reload.

Reading Hardware Temps without C++
To get kernel-level CPU and GPU data, I bypassed writing native Windows plugins and utilized the systeminformation npm package. By running the Electron backend with administrative privileges, Node can read the motherboard sensors directly.

TypeScript
// Hardware Polling loop
setInterval(async () => {
const graphics = await si.graphics();
// Find the dedicated GPU (safely handle undefined temp sensors)
const gpu = graphics.controllers.find(g => (g.temperatureGpu ?? 0) > 0) || graphics.controllers[0];

dashboardWin.webContents.send('telemetry-update', {
gpuTemp: gpu.temperatureGpu,
gpuLoad: gpu.utilizationGpu
});
}, 2000);
The 1-Click Lock
The final piece of the puzzle was killing the "drag and drop" friction. Using Electron's screen API, the app automatically scans your hardware for a display matching the 1280x400 aspect ratio. When you click "Lock to Mini-Display," it calculates the exact X/Y coordinates of that monitor, teleports the dashboard there, and locks it into full screen.

The Result
I packaged it up with electron-builder into a standalone .exe. It takes up a fraction of the system resources of legacy tools, natively supports CSS variable theming, and most importantly, it's completely free.

Stop paying for clunky software.

Links:

Download the 1-Click Windows Installer at VibeAxis.com

Star the Repo or fork the code on GitHub

Let me know what you think of the architecture, or if you have any ideas on how to optimize the IPC bridge even further!