ZHIVOGLAS
This site is a hybrid application that can live on the web as a lightweight site and on the desktop as heavy software for any device.
The application turns into an independent tool. Serwist instantly launches heavy WASM binaries and the UI core even in complete absence of network.
Interface rendering via WebGL ensures 60 FPS. Rust takes over memory management and complex calculations unavailable to regular websites.
Coupled with Electron, browser limits are lifted. You get infinite data storage in IndexedDB and direct access to local files.
Node.js or Python servers that run continuously and render content remotely.
Next.js functions (Vercel/Lambda). The code runs in the cloud only at the moment of a click.
CDN serves static files instantly, and all logic and visualization are moved to the client's device.
The Rust + Electron stack blurs the boundaries between a web page and professional software, while maintaining the freedom of the web.
Architecture Evolution
Сегодня это гибридный сайт-приложение. Завтра этот движок (Rust + WGPU) станет поддерживаться и расширяться нашим браузером. Скоро премьера!
In the hybrid stack, data remains under your full control. Rust provides military-grade client-side encryption, and the Electron/PWA architecture allows storing keys and files locally, bypassing vulnerable cloud servers.
Using IndexedDB and local files in Electron eliminates the need to transfer sensitive data to external servers. No APIs — no points for remote attack.
Thanks to Rust, AES-256 or RSA operations are performed instantly. Media streams and databases are encrypted on the fly, providing privacy without dropping FPS in the visualizer.
Rust's strict typing prevents 70% of security bugs. In a PWA, data is isolated by the browser, and in Electron, you define access boundaries yourself via a secure IPC protocol.
The hybrid Rust + Electron/Wasm approach is significantly more reliable than regular JS, but running in the Chromium environment imposes its own specific risks.
Comparison of the technology stack with industry standards: from native programs to heavy web solutions without introducing a custom browser engine (yet).
Hybrid core: Rust logic, caching via a modern Service Worker. Allows the site to run like an installed program.
The classic path of software creation (like VLC or Photoshop). Direct interaction with the OS kernel and graphics card.
Renders the interface via Skia/Impeller. A popular competitor for cross-platform applications.
Niche: Examples: Figma, Photopea. Professional tools in the browser running at the speed of local software.
+ Link accessibility + Rust power.
+ Safe memory management.
+ Perfect for audio/video visualizers.
- Dependency on WebGL/WebGPU support in the browser.
Niche: Examples: VS Code, Discord, Obsidian. When a "heavy" desktop with access to user files is needed.
+ Work with unlimited data volumes (HDD/SSD).
+ Deep integration with system menus and tray.
+ Native performance of the Rust core.
- High RAM consumption.
Niche: Examples: Bruno, Zed (partially). Light system utilities where minimal installer size is crucial.
+ The binary file weighs 10-15 times less than Electron.
+ Maximum security due to the Rust backend.
+ Usage of the system WebView (less RAM).
- Different engine behavior on Windows (WebView2) and macOS (WebKit).
What should developers and users expect? The investment of time and money is the only downside.
High performance and reliability for the site are guaranteed, although this will be the most labor-intensive process. But in the end, you will get a universal website-application for any device that works not only online, but also without the Internet! Everything at the highest level: Smooth graphics, 3D engines, and particles at 60+ FPS (via egui/WebGL). Cryptography, physics, signal and sound processing without interface lags. Data processing: Working with gigabyte JSON/binary files right in the browser. Local database storage, which is critical for privacy and security. Full-fledged work with local files takes the site to the application level. Rust logic runs in Chrome, on Windows, macOS, and Linux. Security: Wasm code is harder to decompile than regular JavaScript. Background work, access to USB, COM ports, and specific hardware are available.
Like extremes? Using Electron provides super capabilities and the highest performance for a website! While in a regular browser Wasm lives in a "sandbox", in Electron it gets full access to system resources through the Node.js process. How does it work? Wasm still can't write to disk directly, but you can call a function from Node.js that has access to the file system. You can save files of any size (terabytes), create folders, and work with config files right in the system. In the browser, a tab is limited (usually 2–4 GB). In Electron (especially in the main process), you can use as much RAM as is available on the user's PC. This is critical for processing heavy data in Wasm. Through Electron, Rust code (via the Node.js bridge) can work with USB devices and COM ports, access Bluetooth, manage system windows, take screenshots, or run in the tray! In the regular web, SharedArrayBuffer (needed for multithreading in Wasm) is often disabled due to security concerns (Spectre-type attacks). In Electron, you just enable one flag in settings, and multithreaded Rust operates at full capacity. How to combine Rust and Electron? There are two main paths: Wasm + IPC and Node-API (NAPI-RS). This is a full-fledged native code. It runs many times faster. You have direct access to std::fs, std::net, and all Rust crates without browser restrictions. Here, Electron acts as a "super-shell". File Access: While the PWA version is limited to IndexedDB, the Electron version can use std::fs (via the bridge) to work with a local media library. Performance: You can allocate more memory and CPU priority to the application. Performance 🔥 Extreme!