Last verified
Build node-based flow graph UIs in the terminal with a Rust library that handles pan, zoom, drag, and custom node rendering on ratatui.
Teams building terminal applications sometimes need a visual graph layer: a dependency graph, a pipeline view, a network topology display. Rataflow provides that layer as a Cargo dependency, keeping the binary self-contained without requiring a web frontend.
If the graph is static and read-only with no user interaction, a simpler ASCII diagram library or an SVG-to-text renderer avoids the interaction overhead rataflow adds.
Full interaction coverage is included: multi-select, drag, connection validation with custom validators, context-menu events on nodes and edges, and node resizing. These are the features a terminal-based visual editor needs beyond basic display.
If the graph has 40,000 or more nodes that all need to be rendered simultaneously, check the README performance benchmarks first. At that scale, drag frames average ~18ms in release builds.
Rataflow directly mirrors the xyflow API: nodes, edges, FlowEvents, handles, and companion widgets map across with the same conceptual model. Teams that have built web apps with xyflow can apply the same graph design patterns in a terminal application.
If the target users access the application from a browser, xyflow in a React app is the appropriate tool. Rataflow targets native terminal processes, not web pages.
Terminal UI frameworks give developers a fixed grid of character cells and nothing more. Building a node graph on top of that grid requires solving a chain of problems: tracking world-space float positions that exceed the terminal's u16 coordinate range, rendering nodes that scroll partially off screen, drawing edges that cross each other without overwriting glyphs, and processing mouse events at 125-1000Hz before they queue up and lag the display.
The practical result is that adding a flow graph to a TUI application without a library means writing the layout engine, coordinate transforms, z-ordering, edge routing, and input coalescing from scratch before anything visible exists. Teams typically avoid it and reach for a web frontend instead, adding a browser dependency to what would otherwise be a lightweight terminal tool.
Node and edge content is defined by the NodeContent and EdgeContent traits, so each node can render any Rust type: a text block, a sparkline chart, a live image via ratatui-image, or a custom shader effect via tachyonfx. The graph model stores the content; rataflow handles positioning, z-ordering, and interaction.
Panning, zooming, dragging, and multi-selection work from the first frame with no configuration. Box selection runs on right-drag, node resizing uses a bottom-right grip, and keyboard navigation supports both spatial arrow-key and sequential Tab movement. All keybindings are rebindable via an actions API. Auto-pan activates when dragging near the canvas edge.
Pass a list of edges and rataflow assigns node positions using a layered Sugiyama algorithm, with configurable direction (top-to-bottom, left-to-right) and spacing. For custom positioning, compile out the sugiyama feature flag and set positions via set_node_positions with any external algorithm.
Step, straight, and floating edge types are built in. Crossing edges resolve to proper junction glyphs instead of overwriting each other. Braille edges merge by combining dot patterns within a cell, producing smooth diagonal lines in the terminal without ASCII artifacts.
The serde feature flag enables serialization and deserialization of graph snapshots covering both topology and content. The examples directory includes save_restore and undo_redo demonstrations using this API.
The ratzilla feature flag targets WebAssembly, allowing rataflow graphs to run in a browser using a WebGL2 canvas. The overview demo at rataflow.furkankly.dev runs the native example compiled to WASM, with the same graph topology and portable node types.
Developer libraries for building interactive node graphs divide by target runtime: browser-based toolkits in JavaScript versus terminal-based libraries in Rust. rataflow occupies the terminal side, with no browser dependency and no paid tier.
JointJS+ (Rappid) is a widely deployed commercial graph library for the browser. It ships with a React component API, pre-built shapes, and an SVG renderer, and requires a commercial license for production use with per-seat or per-project pricing.
| Feature | rataflow | JointJS+ |
|---|---|---|
| License | MIT | Commercial (paid license required) |
| Target environment | Terminal / WASM | Browser (JavaScript/React) |
| Layout | Sugiyama (built-in) | Dagre, manual, or custom |
| Serialization | serde (opt-in) | JSON (built-in) |
| Renderer | Terminal cell buffer + WASM WebGL2 | SVG/DOM |
| Pricing | Free (self-hosted) | Paid, per seat or project |
rataflow is the better choice when the target environment is the terminal: a Rust CLI, a server-side monitoring dashboard, or any application where users interact through a terminal emulator. The MIT license means no licensing friction for commercial products built on it.
JointJS+ is worth considering when the application is already browser-based, the shape library and SVG rendering quality are required, and the commercial license cost is acceptable. It has a mature API with years of production use; rataflow is newer and not yet at a stable 1.0.
xyflow is the open source browser-based flow library that rataflow was directly inspired by. The comparison is useful for teams choosing their application architecture.
| Feature | rataflow | xyflow |
|---|---|---|
| License | MIT | MIT |
| Target environment | Terminal / WASM | Browser (React/Svelte) |
| Drag frame at 625 nodes | ~1.0ms native, ~8ms WASM | ~11ms |
| At 10,000 nodes (WASM) | ~8ms | not comparable (requires ~11ms at 625) |
| Distribution | Rust binary | Node.js web app |
xyflow is the right choice for a web application: React integration, a large ecosystem of plugins, and a mature API with many real-world production apps behind it. rataflow is the right choice when the application lives in the terminal, the team is writing Rust, and adding a web frontend is not the preferred path.
Install rataflow into your Rust project with Cargo.
```bash
cargo add rataflow
```Yes. The examples directory includes basic_async.rs, which shows the tokio event loop pattern. The library itself is not async, but it integrates with an async runtime by processing events forwarded from the runtime's input loop. The async and sync examples differ only in how events are polled, not in how the graph is used.
crossterm is the default and ships with the library. termion and termwiz are opt-in feature flags. WASM builds use ratzilla. All four share the same graph model and rendering code; only the input event conversion differs by backend.
Yes, with the serde feature flag. It enables serialization and deserialization of graph snapshots covering both topology and content types. The examples directory includes save_restore and undo_redo demonstrations using this feature.
Nodes render into per-node scratch buffers, so a node at a negative world-space position draws the visible portion correctly. ratatui's u16 buffer cannot address negative coordinates; rataflow handles that at a signed-integer clipping stage before the final u16 cast.
The crate is MIT licensed and functional, with published examples covering every major feature. The repository was created in August 2026 and has not yet reached a 1.0 release, so the API may change in minor versions. For production use, pin the exact crate version in Cargo.toml and review the changelog before upgrading.
Blender's widget system for Python, Rust, JavaScript and C apps
Alternative to
PICO-8
Python retro game engine with built-in editors and browser export.
Alternative to
LightScribe Toolbox
Burn visible images into standard CD, DVD, or Blu-ray discs.
Alternative to
Lazyweb
MCP server for Awwwards design inspiration, no API key required.
Alternative to
Tailwind UI
200+ copy-paste React and Next.js components, MIT licensed, no package
136 file tools for images, PDFs and video, no uploads or accounts.
Sponsors
Alternative to
Superhuman
AI email assistant that drafts replies and clears your inbox
Alternative to
Grok Bot
AI teammates you own: your keys, your model, your machine.
Live monitoring on LinkedIn, X, Reddit & more. Agentic social listening for startups.
The projects we add and every new guide. Free, unsubscribe any time.
Claude Code to 
OpenCode
Jira to 
Windshift
Notion to 
AppFlowy
Slack to 
Mattermost
Linear to 
GitLab
Wispr Flow to 
Handy
Arc to 
Zen Browser
CapCut to 
Concat
Grok Bot to 
rakazo
Superhuman to 
Inbox Zero
Airtable to 
AITable
Muse to 
OpenClaw
Railway to 
Coolify
GitHub Copilot to 
Cline
Datadog to 
NetdataConfluence to 
Wiki.js
Microsoft Teams to 
Rocket.Chat
Firebase to 
Supabase
Pinecone to 
Qdrant
Zapier to 
n8n
1Password to 
KeePassXC
Devin AI to 
OpenHands
Asana to 
Leantime
Contentful to 
Strapi
