deskify
Turn websites into first-class Linux desktop applications with Rust, Tauri, and the system WebView.
Build native-feeling, standalone web app wrappers with CLI-first Linux integration.
Screenshots: KDE Plasma on Arch Linux (alpha MVP workflow).
Why Deskify Exists
Web apps are now core tools, but Linux desktops still treat them like second-class citizens.
- Electron-based wrappers solve distribution, but often at high RAM/disk cost.
- PWAs help in some browsers, but desktop integration is inconsistent across environments.
- The original Nativefier proved the need, but it is now unmaintained.
deskify takes a Linux-first approach: it turns a website into a native-feeling desktop app using Tauri and the system webview (for example webkit2gtk) instead of bundling a full browser engine per app.
Problem Fit (Why Deskify vs. Other Approaches)
Deskify is optimized for Linux users who want native desktop integration and CLI-friendly automation for web apps, without shipping a bundled browser runtime per app.
The comparison below is intentionally rough and practical (not benchmark marketing). It describes tradeoffs, not winners in every category.
| Approach | Runtime model | Desktop integration | Automation / scripting | Isolation / sandbox | Setup complexity | Offline capability |
|---|---|---|---|---|---|---|
| Electron / Nativefier | Bundled Chromium per app | Good | Low to medium | Per-app process, app-bundled runtime | Easy to medium | Depends on the site |
| PWA | Browser runtime | Limited / browser-dependent | Low | Shared browser context | Very easy | Depends on browser + site |
| Flatpak web app models | Sandbox-oriented runtime model | Good | Limited | Strong sandbox model | Medium | Depends on runtime + site |
| Deskify | System WebView | Native (.desktop, icons, WMClass) |
High (CLI-first) | Medium (shared system WebView security model) | Medium (Tauri prerequisites) | Depends on the site |
Deskify Focus (Today)
Deskify focuses on:
- system-native Linux desktop integration
- minimal runtime overhead by relying on the system WebView
- automation-friendly CLI workflows
- straightforward local install/remove lifecycle management
Deskify intentionally does not aim to:
- replace full browser sandbox products
- provide a cross-platform abstraction layer
- ship bundled browser runtimes per generated app
How Deskify Works Today (Alpha / MVP)
deskify is ready for public use and testing as an early MVP, but it is not production-hardened yet.
- Platform scope: Linux only
- Current architecture: one generated Tauri wrapper project per app
- Build model:
deskifycompiles the wrapper locally on your machine - Why this MVP design: simpler debugging, isolated failures, low contributor complexity
- Tradeoff: build time and distro-specific setup issues become user-facing
- Test coverage: currently limited (core behavior is implemented, automated coverage is growing)
MVP Architecture (Today)
flowchart TD
A[deskify CLI] --> B[Generate temporary Tauri wrapper project]
B --> C[Fetch or copy icon]
C --> D[Write tauri.conf.json + source files]
D --> E[Run cargo tauri build locally]
E --> F[Install binary to local executable dir]
F --> G[Install icon + .desktop entry]
G --> H[Launch from Linux app menu]
Known Limitations
- Requires Tauri/Linux system dependencies to be installed locally before
deskify build - Generated app build success can vary by distro/system setup (WebKitGTK/Tauri prerequisites)
- No official cross-platform support (Windows/macOS) yet
- GitHub Releases / binary automation for
deskifyitself may lag behind source updates during early MVP - DRM/protected-media services may not work reliably in the system WebView backend even if they work in a full browser (depends on WebView/DRM support)
Where Deskify Is Going
Deskify aims to make web applications first-class Linux desktop applications.
Planned evolution (direction, not promise):
- Shared runtime model for multiple apps
- Per-app config and icon installs without full rebuilds
- Stronger Linux desktop integration (deployment, automation, kiosk/admin workflows)
- Better distro compatibility guidance and troubleshooting
The current per-app build approach is intentional for the MVP. The goal is to keep it simple now while making the longer-term direction visible.
Planned Evolution (Concept)
flowchart TD
A[deskify CLI] --> B[deskify runtime binary]
A --> C[App config files]
A --> D[Icons + .desktop entries]
C --> E[apps/chatgpt.json]
C --> F[apps/home-assistant.json]
B --> G[Load app config at launch]
G --> H[Open site in system webview]
D --> I[Linux app menu integration]
Why Not Just Use Flatpak Web Apps / PWAs / Electron?
The table above covers the technical tradeoffs in more detail. In practice, deskify is most useful when you want:
- a CLI-first workflow for repeatable installs and automation
- Linux-native desktop integration (
.desktop, icons, window class behavior) - a system-WebView-based runtime model instead of shipping a bundled browser per app
Key Features
- System-WebView Runtime Model: Generated wrappers stay small because Deskify relies on the system WebView instead of bundling a browser runtime per app.
- Automatic Icon Fetching: Scrapes high-quality 128x128 favicons automatically using the Google Favicon API.
- Layered Icon Fallbacks: Tries site-provided icons first (
<link rel="icon">,/favicon.ico), then falls back to the Google Favicon API, then a dummy icon. - XDG-Compliant System Integration: Safely creates
.desktopentries in~/.local/share/applicationsand manages application icons in~/.local/share/icons/hicolor/. - Wayland/X11 Ready: Perfectly binds
StartupWMClassto ensure your DE groups the app exactly to its custom icon (no generic gear icons in GNOME/KDE taskbars). - Kiosk / Fullscreen Mode: Pin applications perfectly as dashboards.
- User-Agent Spoofing: Trick picky sites (like WhatsApp Web) into working within the webview.
- Clean App Management: Effortlessly list and remove created apps without leaving orphaned files behind.
🚀 Installation
1. System Dependencies
Because deskify compiles Tauri applications natively on your machine, you need the standard Tauri prerequisites installed before using it.
On Ubuntu / Debian:
sudo apt update
sudo apt install libwebkit2gtk-4.1-dev \
build-essential \
curl \
wget \
file \
libssl-dev \
libgtk-3-dev \
libayatana-appindicator3-dev \
librsvg2-dev
On Arch Linux / Manjaro:
sudo pacman -S webkit2gtk-4.1 \
base-devel \
curl \
wget \
file \
openssl \
appmenu-gtk-module \
gtk3 \
libappindicator-gtk3 \
librsvg \
libvips
(For Fedora or other distros, refer to the Tauri Prerequisites Guide.)
2. Rust & Tauri CLI
You'll need the Rust compiler and the Tauri CLI to compile the generated apps.
# Ensure Rust is installed
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
# Install Tauri-CLI globally
cargo install tauri-cli --version "^2.0.0"
3. Install deskify
Clone the repository and install it directly via Cargo:
git clone https://github.com/spalencsar/deskify.git
cd deskify
cargo install --path .
🛠️ Usage
Creating an App (build)
The build subcommand requires a --url and a --name.
deskify build --url "https://chatgpt.com" --name "ChatGPT"
Once the build finishes, ChatGPT will instantly appear in your system Application Launcher (e.g., Rofi, Wofi, GNOME Dash).
deskify derives a safe internal ID from the app name (for example, ChatGPT becomes chatgpt).
Advanced Build Options
deskify build \
--url "https://web.whatsapp.com" \
--name "WhatsApp" \
--fullscreen \
--user-agent "Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/120.0.0.0 Safari/537.36" \
--dark-mode \
--width 1280 \
--height 720
Frameless example (without fullscreen):
deskify build \
--url "https://chat.com" \
--name "Chat" \
--no-decorations \
--width 1200 \
--height 800
Preview the generated Tauri config without building/installing:
deskify build --url "https://chat.com" --name "Chat" --print-config
Preview planned actions only (dry run):
deskify build --url "https://chat.com" --name "Chat" --dry-run
--icon <PATH>: Provide a custom PNG icon instead of auto-downloading one.--fullscreen: Starts the app in Kiosk mode.--no-decorations: Disables native window decorations (frameless window; useful for dashboards/kiosk setups).--user-agent <UA>: Useful to bypass webview restrictions on certain platforms.--dark-mode: Forces the Tauri webview into a dark theme.--width <PX>/--height <PX>: Sets the startup resolution.--print-config: Prints the generatedtauri.conf.jsonand exits.--dry-run: Shows planned actions without building/installing.
Managing Apps (list & remove)
You can view all applications generated by deskify:
deskify list
Output:
Installed Deskify Apps:
- ChatGPT (Internal ID: chatgpt)
- Home Assistant (Internal ID: home-assistant)
To entirely uninstall an app (including the binary, desktop entry, and icons):
deskify remove chatgpt
remove expects this internal ID (sanitized lowercase letters, numbers, -), not the display name.
Updating Apps (update)
Rebuild and reinstall an existing app ID without manually running remove + build:
deskify update chat --url "https://chat.com" --name "Chat" --no-decorations
Alpha note: update currently requires --url because Deskify does not persist app URLs/config metadata yet.
You can also preview an update:
deskify update chat --url "https://chat.com" --dry-run
deskify update chat --url "https://chat.com" --print-config
Diagnostics (doctor)
Check local prerequisites and common environment issues (Rust/Cargo, cargo tauri, pkg-config, directories):
deskify doctor
🧪 Manual Smoke Test Checklist (Before a Public Release)
deskify build --url "https://example.com" --name "Example"
deskify list
deskify remove example
Also test invalid IDs:
deskify remove ../foo
deskify remove FooBar
Expected: clean validation error and no unintended file deletion.
🏷️ Versioning & GitHub Releases (MVP)
- Recommended tag format during MVP:
v0.1.0-alpha.N - Start with source-first releases (repository + tags)
- Add automated binary releases later via GitHub Actions
For the current public alpha, use v0.1.0-alpha.2 (and continue with v0.1.0-alpha.N for follow-up releases).
📦 Open Source Acknowledgements
deskify is built on the shoulders of giants. It leverages the following fantastic open-source projects:
- Tauri - The core framework driving the native wrap.
- Clap - Command-Line Argument Parser for Rust.
- Anyhow - Excellent error handling context.
- Ureq - Minimalist sync HTTP request library (used for icon fetching).
- Directories - Abstractions for standard OS directories (XDG Base Dirs).
📝 License
This project is licensed under the MIT License.