DEV Community: Noel Paul

Liquid Glass: Physical Optical Lensing & Glassmorphism UI Engine for Linux in Rust (WGPU)

Noel Paul — Sun, 25 Oct 2026 14:23:51 +0000

Most "frosted glass" or "glassmorphism" implementations on the web and Linux desktops boil down to a simple 2D box-blur shader layered over a background capture.

While that looks pleasant, it isn’t how real glass behaves. Real optical glass has curvature, refraction, chromatic dispersion (wavelength splitting), surface tension, and directional specular sheen.

Over the last few weeks, I’ve been building Liquid Glass: an open-source rendering engine and UI framework written in Rust, WGPU, and WGSL that brings true physical optical glass simulation to Linux desktop apps and Wayland widgets.

🔬 The Optical Physics Under the Hood

Instead of drawing flat quads with blurred backdrops, Liquid Glass computes analytical Signed Distance Fields (SDFs) per fragment:

1. Plano-Convex Snell Refraction

We compute the surface height $h(p)$ and its normal gradient $\nabla h(p)$ analytically across the geometry boundary:
$$N = \text{normalize}\begin{pmatrix} -\nabla h_x \ -\nabla h_y \ 1 \end{pmatrix}$$

Using Snell's Law ($IOR = 1.33 - 1.52$), light rays bend towards the optical center, producing true optical barrel distortion and magnification of underlying desktop wallpapers.

2. Spectral Chromatic Dispersion

Real glass splits white light into spectral wavelengths at curved meniscus boundaries. Liquid Glass offsets red, green, and blue texture sample coordinates proportionally to the surface refraction angle:

let r_offset = refract_vec * (1.0 - dispersion);
let g_offset = refract_vec;
let b_offset = refract_vec * (1.0 + dispersion);

This gives chamfered edges and button rims an unmistakable physical glow.

3. Directional Solar Rim Lighting & Specular Sheen

A dual-lobe Blinn-Phong specular reflection catches a simulated directional sunlight vector ([-0.6, -0.8]), producing bright 1.5px grazing meniscus catches.

⚡ Performance: 0.0% CPU When Idle

A common pitfall with custom Linux widgets and shaders is battery drain from uncapped render loops. Liquid Glass was architected for zero idle overhead:

Kernel epoll_wait Blocking: When no audio is playing and no pointer is moving, the event loop stops spinning and sleeps in Wayland's event_queue.blocking_dispatch(). Top benchmark:

   PID    USER  %CPU  %MEM  COMMAND
   241729 zius   0.0   1.2  glass-panel

Single Quad Draw Call: The entire UI (capsule glass, vinyl grooves, music notes, equalizer bars, timeline, scrubber knob, transport buttons, speaker) is rendered in a single quad draw call inside WGSL.
In-Memory Pre-Scaled Wallpaper Cache: Moving or dragging the widget samples wallpaper crops in sub-milliseconds without disk I/O.

🎨 Building UI Components with `glass-ui`

Building high-level interfaces shouldn't require writing raw WGSL shaders. The workspace includes glass-ui, providing pre-built interactive components:

GlassCard / GlassIsland: Physical glass containers with adjustable corner radius, curvature, and bevel.
GlassButton: Tactile spring-animated buttons with click compression (0.94x) and smooth recovery.
GlassToggle: Pill switch with spring-animated knob transitions.
GlassSlider: Draggable timeline scrubber with track rail, active fill, and thumb.

use glass_ui::{GlassWidget, GlassCard, GlassButton, GlassToggle, GlassSlider};

let mut widget = GlassWidget::new();

// Floating container
widget.add_card(GlassCard::island(0.1, 0.1, 0.8, 0.8).blur(32.0));

// Interactive controls
widget.add_button(GlassButton::new(0.15, 0.25, 0.30, 0.10, "Play"));
widget.add_toggle(GlassToggle::new(0.50, 0.25, 0.15, 0.08, true));
widget.add_slider(GlassSlider::new(0.15, 0.50, 0.70, 0.05, 0.65));

// In your event loop:
widget.on_pointer_move(x, y);
widget.update(dt);
let surfaces = widget.collect_surfaces();
renderer.render(&surfaces)?;

🚀 Two Running Targets

Floating Wayland Desktop Island (glass-panel): Uses zwlr_layer_shell_v1 on Hyprland/wlroots to float transparently over your wallpaper with real-time MPRIS media playback control.

   cargo run -p glass-panel --release

Cross-Platform Desktop Window (simple-window): Uses standard winit and wgpu to render a windowed UI component playground.

   cargo run -p simple-window

🤝 Open Source & Contributing

We'd love community help expanding this into a full-featured desktop UI ecosystem:

Building new glass-ui components (GlassTextInput, GlassTooltip, GlassContextMenu).
Supporting more compositor protocols (KDE KWin blur, COSMIC compositor).
New showcase widgets (weather, clock, system monitor).
GitHub Repository: https://github.com/ziuus/liquid-glass
Contributing Guide: CONTRIBUTING.md

If you find this interesting or want to support native graphics on Linux, consider starring the repo on GitHub! ⭐

Liquid Glass: Physical Optical Lensing & Glassmorphism UI Engine for Linux in Rust (WGPU)

Noel Paul — Thu, 22 Oct 2026 11:33:07 +0000

Most "frosted glass" or "glassmorphism" implementations on the web and Linux desktops boil down to a simple 2D box-blur shader layered over a background capture.

🔬 The Optical Physics Under the Hood

Instead of drawing flat quads with blurred backdrops, Liquid Glass computes analytical Signed Distance Fields (SDFs) per fragment:

1. Plano-Convex Snell Refraction

Using Snell's Law ($IOR = 1.33 - 1.52$), light rays bend towards the optical center, producing true optical barrel distortion and magnification of underlying desktop wallpapers.

2. Spectral Chromatic Dispersion

let r_offset = refract_vec * (1.0 - dispersion);
let g_offset = refract_vec;
let b_offset = refract_vec * (1.0 + dispersion);

This gives chamfered edges and button rims an unmistakable physical glow.

3. Directional Solar Rim Lighting & Specular Sheen

A dual-lobe Blinn-Phong specular reflection catches a simulated directional sunlight vector ([-0.6, -0.8]), producing bright 1.5px grazing meniscus catches.

⚡ Performance: 0.0% CPU When Idle

A common pitfall with custom Linux widgets and shaders is battery drain from uncapped render loops. Liquid Glass was architected for zero idle overhead:

Kernel epoll_wait Blocking: When no audio is playing and no pointer is moving, the event loop stops spinning and sleeps in Wayland's event_queue.blocking_dispatch(). Top benchmark:

   PID    USER  %CPU  %MEM  COMMAND
   241729 zius   0.0   1.2  glass-panel

Single Quad Draw Call: The entire UI (capsule glass, vinyl grooves, music notes, equalizer bars, timeline, scrubber knob, transport buttons, speaker) is rendered in a single quad draw call inside WGSL.
In-Memory Pre-Scaled Wallpaper Cache: Moving or dragging the widget samples wallpaper crops in sub-milliseconds without disk I/O.

🎨 Building UI Components with `glass-ui`

Building high-level interfaces shouldn't require writing raw WGSL shaders. The workspace includes glass-ui, providing pre-built interactive components:

GlassCard / GlassIsland: Physical glass containers with adjustable corner radius, curvature, and bevel.
GlassButton: Tactile spring-animated buttons with click compression (0.94x) and smooth recovery.
GlassToggle: Pill switch with spring-animated knob transitions.
GlassSlider: Draggable timeline scrubber with track rail, active fill, and thumb.

use glass_ui::{GlassWidget, GlassCard, GlassButton, GlassToggle, GlassSlider};

let mut widget = GlassWidget::new();

// Floating container
widget.add_card(GlassCard::island(0.1, 0.1, 0.8, 0.8).blur(32.0));

// Interactive controls
widget.add_button(GlassButton::new(0.15, 0.25, 0.30, 0.10, "Play"));
widget.add_toggle(GlassToggle::new(0.50, 0.25, 0.15, 0.08, true));
widget.add_slider(GlassSlider::new(0.15, 0.50, 0.70, 0.05, 0.65));

// In your event loop:
widget.on_pointer_move(x, y);
widget.update(dt);
let surfaces = widget.collect_surfaces();
renderer.render(&surfaces)?;

🚀 Two Running Targets

Floating Wayland Desktop Island (glass-panel): Uses zwlr_layer_shell_v1 on Hyprland/wlroots to float transparently over your wallpaper with real-time MPRIS media playback control.

   cargo run -p glass-panel --release

Cross-Platform Desktop Window (simple-window): Uses standard winit and wgpu to render a windowed UI component playground.

   cargo run -p simple-window

🤝 Open Source & Contributing

We'd love community help expanding this into a full-featured desktop UI ecosystem:

Building new glass-ui components (GlassTextInput, GlassTooltip, GlassContextMenu).
Supporting more compositor protocols (KDE KWin blur, COSMIC compositor).
New showcase widgets (weather, clock, system monitor).
GitHub Repository: https://github.com/ziuus/liquid-glass
Contributing Guide: CONTRIBUTING.md

If you find this interesting or want to support native graphics on Linux, consider starring the repo on GitHub! ⭐

Building GoRoute: An Ultra-Lightweight (<15MB RAM) LLM Gateway in Go

Noel Paul — Sun, 18 Oct 2026 03:32:18 +0000

Most developers using terminal coding agents like Claude Code, OpenCode, Codex, or Cursor end up running an LLM router in the background to handle rate limits, multiple accounts, and model failovers.

Popular tools like OmniRoute and LiteLLM work, but running a full Node.js or Python runtime 24/7 just to proxy HTTP requests consumes 150MB to 300MB of RAM and introduces cold-start latency.

I wanted something that idles at < 6MB RAM, starts instantly, and never panics. So I built GoRoute.

What is GoRoute?

GoRoute is a zero-dependency, compiled LLM gateway and multi-agent router written in Go.

It acts as a local reverse proxy (http://127.0.0.1:8128) sitting between your developer agents and AI providers.

+-------------+       +-------------------+       +-----------------------+
| Claude Code | ----> |                   | ----> | Google Antigravity    |
| OpenCode    | ----> | GoRoute (Go Proxy)| ----> | OpenAI / Anthropic    |
| Codex/Cursor| ----> |   (<15MB RAM)     | ----> | Custom Endpoints      |
+-------------+       +-------------------+       +-----------------------+

Key Capabilities

Sub-15MB Memory Footprint: Compiles to a single 16MB binary with zero external dependencies. Idles under 6MB RAM.
Automatic 429 Failover & Round-Robin: Automatically rotates accounts and instantly fails over across keys if rate limits are hit.
Dual Protocol Translation: Speak OpenAI (/v1/chat/completions) or Anthropic Messages API (/v1/messages) seamlessly.
1-Click Agent Setup: Automatically configures Claude Code, OpenCode, Codex, Cursor, Aider, and Cline with a single command:

   goroute setup all

Seamless OmniRoute Migration: If you already have OmniRoute configured, import your existing credentials and routes in 1 second:

   goroute import-omniroute

Installation & Quick Start

You can install GoRoute directly via curl:

curl -fsSL https://raw.githubusercontent.com/ziuus/goroute/main/install.sh | bash

Or run via npm:

npx goroute setup all

Once installed, check status:

goroute status

Check out the GitHub repo here: https://github.com/ziuus/goroute

I'd love to hear your feedback, feature requests, or questions!

Building a Near-Zero CPU Linux Settings Center in Rust (settings-tui)

Noel Paul — Tue, 13 Oct 2026 11:49:51 +0000

Most desktop Linux users on tiling window managers like Hyprland, Sway, or i3 face the same dilemma: either memorize dozens of CLI arguments across nmcli, bluetoothctl, wpctl, and systemctl, or pull in heavy 500MB+ GUI control centers from GNOME or KDE.

I built settings-tui to bridge that gap with a unified, hyper-lightweight (<9MB, near 0% idle CPU) terminal control center written in Rust with Ratatui.

Subsystems Covered

Network: Wi-Fi network scanning, WPA/WPA2 interactive password modals, and Ethernet stats via NetworkManager D-Bus.
Audio: Sink/source volume, streams, and muting via WirePlumber / PipeWire.
Bluetooth: Device scanning, pairing, and connection management over BlueZ.
Displays & Backlight: Hyprland IPC monitor modes, resolutions, scale factors, and single-digit brightness control via sysfs.
Power: Battery health, discharge rates, and power profiles via UPower.
Systemd: Service inspection, restarts, and unit status.

The Transaction Engine

Rather than blindly executing shell commands and assuming success, settings-tui implements a transactional lifecycle:
READ CURRENT STATE -> MUTATE -> BOUNDED PROPAGATION WAIT -> READ CANONICAL STATE -> VERIFY POSTCONDITION.

If a Wi-Fi authentication fails or a PipeWire node does not accept a volume change, the TUI transparently reports the exact status badge.

Trying it Out

You can try it instantly without compiling:

npx settings-tui

Or install from source:

git clone https://github.com/ziuus/settings-tui.git
cd settings-tui && cargo run --release

GitHub Repository: https://github.com/ziuus/settings-tui

Contributions, ideas, and feedback are welcome!

Terminal Renaissance is here!!

Noel Paul — Sun, 13 Sep 2026 05:18:57 +0000

Something interesting is happening with the terminal again.

Not a return to the old command line.

A new generation of terminal-first software is being built.

And the reason isn't nostalgia.

Modern terminals are fast, lightweight, composable and automation-friendly. They work well over SSH, can run headlessly, use far fewer resources than many GUI applications, and fit naturally into scripts and larger workflows.

But terminals are also becoming much more than text interfaces.

Interactive TUIs, system dashboards, database clients, infrastructure, monitoring, networking, security, AI, development and automation are all becoming increasingly sophisticated terminal experiences.

AI is accelerating this, but it's only one part of the trend.

The bigger shift is that the terminal is becoming a programmable interface for complex workflows.

I've been exploring this space myself with Vanta, a terminal system monitor built in Rust.

ziuus / vanta

The most complete keyboard-driven terminal dashboard in Rust. One pane, six modes — CPU, memory, disk, network, GPU, processes, clock, calendar, media visualizer. ~3MB binary, 2-5% CPU.

vanta

Your machine, one pane.

A fast, aesthetic terminal system dashboard in Rust. The most complete keyboard-driven terminal dashboard — one pane, six modes, zero mouse.

Vanta collapses everything you care about into one terminal pane: CPU, memory, disk network, GPU, processes, now-playing, a block-digit clock, a calendar, and an audio visualizer. Keyboard only. ~3 MB binary, ~2–5% CPU at the default 30 fps.

npm install -g @ziuus/vanta && vanta

Install

Method	Command	Notes
npm	`npm install -g @ziuus/vanta`	Fetches the prebuilt `linux-x64` binary. No Rust needed.
Prebuilt binary	Releases	Download the `tar.gz`, drop `vanta` on your `PATH`.
cargo	`cargo install --git https://github.com/ziuus/vanta`	Any architecture. Needs a Rust toolchain.
From source	`git clone https://github.com/ziuus/vanta && cd vanta && cargo run --release`	For hacking on it.

One-liner, no install:

npx @ziuus/vanta

Requirements

Linux (vanta reads /proc and /sys). Building from source also needs libdbus:

sudo pacman -S

…

View on GitHub

Maybe terminal-native software is becoming a serious design space again.

And honestly, it feels like we're still early.

Terminal Renaissance is here

Noel Paul — Sun, 13 Sep 2026 05:12:27 +0000

Something interesting is happening with the terminal again.

Not a return to the old command line.

A new generation of terminal-first software is being built.

And the reason isn't nostalgia.

But terminals are also becoming much more than text interfaces.

AI is accelerating this, but it's only one part of the trend.

The bigger shift is that the terminal is becoming a programmable interface for complex workflows.

I've been exploring this space myself with Vanta, a terminal system monitor built in Rust.

Maybe terminal-native software is becoming a serious design space again.

And honestly, it feels like we're still early.

Building Elige: Zero-Hallucination Government Opportunity Intelligence with Google ADK, Gemini 3.5, and Deterministic ASTs

Noel Paul — Mon, 31 Aug 2026 12:41:15 +0000

I created this project and article for the purpose of entering the All Things Agentic Hackathon organized by Google and Devpost.

Excited to share Elige — our submission for the Google & Devpost #AllThingsAgenticHackathon! 🚀

Discovering government grants and subsidies is broken. Most AI chatbots hallucinate legal criteria. We built an autonomous opportunity intelligence agent using Google ADK, Gemini 3.5, and a Deterministic AST Rule Engine to verify and qualify public schemes with 0% hallucination.

🔗 Live Product: https://elige-alpha.vercel.app
📦 GitHub: https://github.com/ziuus/Elige.git

Built on Google Cloud Run & Vertex AI. #GoogleAI #AgenticAI #Gemini #GoogleCloud

Agentic Loops is becoming next...

Noel Paul — Sat, 20 Jun 2026 15:41:31 +0000

Agentic loops are where AI becomes useful beyond one-shot prompting.

Instead of asking once and fixing everything manually, you design a loop:

Plan → Act → Review → Improve → Repeat

That is how AI agents move from giving answers to completing workflows.

Prompting asks for output.
Agentic loops build progress.

Vibe Coding vs AI assisted Engineering

Noel Paul — Thu, 11 Jun 2026 07:12:35 +0000

Vibe coding is good for speed.
Engineer-assisted AI is good for building real products.

There’s a big difference.

Vibe coding is when you keep prompting until something “looks like it works.”
It feels fast, but the codebase can become messy, fragile, and hard to maintain.

Engineer-assisted AI is different.

The engineer still owns the architecture, constraints, testing, security, database design, user flow, and long-term maintainability. AI becomes the accelerator, not the decision-maker.

AI can generate code.
But engineering is not just writing code.

Engineering is knowing:

what should be built,
what should not be built,
where bugs will appear,
how systems scale,
how users break flows,
how to debug,
how to ship safely.

The future is not “AI replacing engineers.”
The future is engineers who know how to command AI properly outperforming those who only use it casually.

Vibe coding can create demos.
Engineer-assisted AI can create products.

That’s the difference.

I Built a Desktop App That Fixes Linux Dual-Boot Folder Access in One Click

Noel Paul — Sun, 10 May 2026 20:17:03 +0000

For years, every time I booted into Linux, I'd SSH into my own machine just to grab a file from my Windows partition. Or worse — I'd reboot, wait for Windows updates, grab the file, and reboot back. Sound familiar?

Dual-booting should be the best of both worlds. In practice? It's a constant dance of "which OS has my files?"

That's why I built Lindy.

The Problem

Every Linux dual-boot user knows this pain:

Windows NTFS partitions don't mount automatically with write access
chown, chmod, fstab edits — it's 2026, why is this still manual?
Every distro handles mount differently
New Linux users give up and stay on Windows

What Lindy Does

Lindy is a Tauri 2 + React desktop app that detects your Windows partitions, scans for user folders, and mounts them with one click. No terminal, no fstab editing, no permission headaches.

One click. Your Windows folders appear in your Linux home.

Features

Smart Auto-Map — Detects Windows partitions (NTFS/exFAT), finds usernames, maps Desktop, Documents, Downloads, Pictures, Music, Videos automatically
Manual Auto-Map — Power users can specify custom mount points and folder selections
Secure — Proper permissions via polkit, no wild chmod 777
Built with Tauri 2 + React + Rust — Lightweight, fast, native performance

The Tech Side

Built entirely in the open:

Tauri 2 for the native desktop shell (tiny bundle vs Electron)
React for the UI
Rust backend handles partition detection and mount logic via Tauri commands
pnpm for dependency management
Cargo.toml: tauri 2, serde, serde_json, tauri-plugin-opener, tauri-plugin-dialog

The mount backend parses lsblk output, detects NTFS/exFAT partitions, finds Windows user directories, and mounts them using system utilities with polkit elevation. All the complexity is hidden behind a clean UI.

Try It

Lindy is open source and available now:

GitHub: https://github.com/ziuus/lindy
Installers: .deb, .rpm, .AppImage available in the repo

I'd love feedback, contributions, or just to hear if this solves the same problem for you that it solved for me.

Have you been fighting with dual-boot file access? Drop a comment — I want to hear your setup horror stories too.

I Built a Desktop App That Fixes Linux Dual-Boot Folder Access in One Click

Noel Paul — Sun, 10 May 2026 20:17:03 +0000

Dual-booting should be the best of both worlds. In practice? It's a constant dance of "which OS has my files?"

That's why I built Lindy.

The Problem

Every Linux dual-boot user knows this pain:

Windows NTFS partitions don't mount automatically with write access
chown, chmod, fstab edits — it's 2026, why is this still manual?
Every distro handles mount differently
New Linux users give up and stay on Windows

What Lindy Does

Lindy is a Tauri 2 + React desktop app that detects your Windows partitions, scans for user folders, and mounts them with one click. No terminal, no fstab editing, no permission headaches.

One click. Your Windows folders appear in your Linux home.

Features

Smart Auto-Map — Detects Windows partitions (NTFS/exFAT), finds usernames, maps Desktop, Documents, Downloads, Pictures, Music, Videos automatically
Manual Auto-Map — Power users can specify custom mount points and folder selections
Secure — Proper permissions via polkit, no wild chmod 777
Built with Tauri 2 + React + Rust — Lightweight, fast, native performance

The Tech Side

Built entirely in the open:

Tauri 2 for the native desktop shell (tiny bundle vs Electron)
React for the UI
Rust backend handles partition detection and mount logic via Tauri commands
pnpm for dependency management
Cargo.toml: tauri 2, serde, serde_json, tauri-plugin-opener, tauri-plugin-dialog

Try It

Lindy is open source and available now:

GitHub: https://github.com/ziuus/lindy
Installers: .deb, .rpm, .AppImage available in the repo

I'd love feedback, contributions, or just to hear if this solves the same problem for you that it solved for me.

Have you been fighting with dual-boot file access? Drop a comment — I want to hear your setup horror stories too.

DEV Community: Noel Paul

Liquid Glass: Physical Optical Lensing & Glassmorphism UI Engine for Linux in Rust (WGPU)

🔬 The Optical Physics Under the Hood

1. Plano-Convex Snell Refraction

2. Spectral Chromatic Dispersion

3. Directional Solar Rim Lighting & Specular Sheen

⚡ Performance: 0.0% CPU When Idle

🎨 Building UI Components with glass-ui

🚀 Two Running Targets

🤝 Open Source & Contributing

Liquid Glass: Physical Optical Lensing & Glassmorphism UI Engine for Linux in Rust (WGPU)

🔬 The Optical Physics Under the Hood

1. Plano-Convex Snell Refraction

2. Spectral Chromatic Dispersion

3. Directional Solar Rim Lighting & Specular Sheen

⚡ Performance: 0.0% CPU When Idle

🎨 Building UI Components with glass-ui

🚀 Two Running Targets

🤝 Open Source & Contributing

Building GoRoute: An Ultra-Lightweight (<15MB RAM) LLM Gateway in Go

What is GoRoute?

Key Capabilities

Installation & Quick Start

Building a Near-Zero CPU Linux Settings Center in Rust (settings-tui)

Subsystems Covered

The Transaction Engine

Trying it Out

Terminal Renaissance is here!!

ziuus / vanta

The most complete keyboard-driven terminal dashboard in Rust. One pane, six modes — CPU, memory, disk, network, GPU, processes, clock, calendar, media visualizer. ~3MB binary, 2-5% CPU.

vanta

Install

Requirements

Terminal Renaissance is here

Building Elige: Zero-Hallucination Government Opportunity Intelligence with Google ADK, Gemini 3.5, and Deterministic ASTs

Agentic Loops is becoming next...

Vibe Coding vs AI assisted Engineering

I Built a Desktop App That Fixes Linux Dual-Boot Folder Access in One Click

The Problem

What Lindy Does

Features

The Tech Side

Try It

I Built a Desktop App That Fixes Linux Dual-Boot Folder Access in One Click

The Problem

What Lindy Does

Features

The Tech Side

Try It

🎨 Building UI Components with `glass-ui`

🎨 Building UI Components with `glass-ui`