Flowsurface stands out by implementing advanced crypto order flow visualization as a native desktop app in Rust. It connects directly to multiple exchange APIs via WebSockets and REST, bypassing third-party data providers entirely. The app processes and aggregates data client-side, rendering heatmaps, footprint charts, and candlestick views with a focus on real-time responsiveness and detailed order book insights. This approach brings unique challenges and tradeoffs that this project tackles with a clean architecture and a modern Rust stack.
What flowsurface does and its architecture
Flowsurface is a native desktop crypto charting application written in Rust, leveraging the iced GUI framework for cross-platform native user interfaces. It supports integration with several popular crypto exchanges including Binance, Bybit, Hyperliquid, OKX, and MEXC, connecting directly to their WebSocket and REST APIs.
The core functionality revolves around advanced order flow visualization: it provides heatmaps (historical Depth of Market - DOM), footprint charts that include imbalance and Point of Control (POC) studies, and traditional candlestick charts. These views help traders analyze market microstructure and order flow dynamics more granularly than typical price charts.
A key architectural choice is client-side data aggregation and processing. Instead of relying on backend servers or intermediary data providers, Flowsurface downloads raw trade and order book data streams directly from exchanges. It aggregates price and volume data locally, supporting customizable price grouping, time aggregations, and volume profiles. This requires efficient real-time data handling and rendering pipelines implemented in Rust.
The app also draws inspiration from existing desktop charting tools like Kraken Desktop and Halloy, emphasizing features such as real-time trade processing, linked multi-monitor panes for synchronized views, and even sound effects for trade events.
Distributed as unsigned prebuilt binaries for Windows, macOS, and Linux, Flowsurface can also be built from source using Rust’s cargo build system, making it accessible for users who want to compile it themselves or contribute.
Technical strengths and tradeoffs
What distinguishes Flowsurface is its native Rust implementation of a complex, real-time order flow visualization tool with direct exchange WebSocket integration. Many similar tools rely on backend services or are browser-based with web tech stacks. Flowsurface’s approach of client-side aggregation and rendering offers a high degree of control and potentially lower latency.
Under the hood, it uses the iced GUI framework, a Rust-native toolkit that compiles to native binaries across platforms. This choice avoids Electron or web-based dependencies, which can bloat resource use or introduce latency.
The codebase handles multiple challenges:
Real-time WebSocket trade and order book data processing: Maintaining a synchronized Level 2 order book state from exchange streams is notoriously tricky. Flowsurface manages this client-side, applying aggregation and filtering logic to produce footprint and heatmap visualizations.
Advanced chart rendering: Footprint charts require displaying bid/ask imbalances, volume nodes, and POC studies within a compact grid, updating with every trade tick. The rendering code must be efficient to keep the UI responsive.
Customization and extensibility: The app supports configurable price grouping and time aggregations, which means the data pipeline must be flexible.
Cross-platform deployment: Building native apps for Windows, macOS, and Linux with consistent behavior is a challenge; iced helps but there are still platform-specific nuances.
The tradeoff is the complexity of shipping unsigned binaries, which can trigger OS security warnings during installation. Users need to manually allow execution on macOS and Windows, which might deter less technical users. Also, client-side aggregation could be resource intensive depending on the volume of market data and user hardware.
The code quality appears solid with clear separation of concerns between WebSocket handling, data aggregation, and UI rendering. The repository also provides prebuilt binaries, which indicates attention to usability beyond just source builds.
Quick start
Method 1: Prebuilt Binaries
Standalone executables are available for Windows, macOS, and Linux on the Releases page.
Having trouble running the file? (Permission/Security warnings)
Since these binaries are currently unsigned they might get flagged.
- Windows: If you see a “Windows protected your PC” pop-up, click More info -> Run anyway.
- macOS: If you see “Developer cannot be verified”, control-click (right-click) the app and select Open, or go to System Settings > Privacy & Security to allow it.
Method 2: Build from Source
Requirements
- Rust toolchain
- Git version control system
- System dependencies:
- Linux:
- Debian/Ubuntu:
sudo apt install build-essential pkg-config libasound2-dev - Arch:
sudo pacman -S base-devel alsa-lib - Fedora:
sudo dnf install gcc make alsa-lib-devel
- Debian/Ubuntu:
- macOS: Install Xcode Command Line Tools:
xcode-select --install - Windows: No additional dependencies required
- Linux:
Option A: cargo install
# Install latest globally
cargo install --git https://github.com/flowsurface-rs/flowsurface flowsurface
This setup shows a balance between user convenience (prebuilt binaries) and developer friendliness (build from source). The use of cargo install with the Git URL is a neat shortcut for Rust users wanting the latest version without cloning and building manually.
Verdict
Flowsurface is a compelling example of a native Rust desktop app handling complex, real-time crypto order flow visualization by connecting directly to exchange WebSocket feeds. It’s well suited for traders and developers who want a performant, native tool that avoids backend dependencies and web technology overhead.
The tradeoffs are clear: unsigned binaries may complicate installation for some, and the client-side aggregation approach demands decent local resources and careful handling of WebSocket streams. The iced GUI framework choice means the app has a lightweight native feel but may not match the polish of mature commercial charting platforms.
If you’re interested in how to implement real-time WebSocket data processing, footprint chart rendering, and a multi-pane linked desktop UI in Rust, this repo is worth studying. It’s also a practical tool if you want a native crypto charting app with advanced order flow features and direct exchange integration.
Not for casual users who prefer turn-key, fully polished commercial software, but a solid foundation for Rust developers and traders looking for transparency and control in their charting stack.
Related Articles
- 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
- Flowise: visual low-code AI agent builder with a modular TypeScript monorepo — Flowise offers a visual drag-and-drop low-code platform to build AI agents and LLM apps, with a Node.js backend and Reac
- Vaultwarden: a resource-efficient Rust implementation of the Bitwarden server API — Vaultwarden is a lightweight, Rust-based server compatible with the Bitwarden API, optimized for self-hosting with low r
- Inside Grafana: a modular platform for monitoring and observability — Grafana is an open-source monitoring platform with an extensible plugin architecture enabling diverse data source integr
- Crawlee: a TypeScript library for stealthy web scraping and browser automation — Crawlee is a TypeScript library for web scraping and browser automation with human-like stealth. Supports Playwright, Pu
→ GitHub Repo: flowsurface-rs/flowsurface ⭐ 1,514 · Rust