z8run

Open-Source Visual Flow Engine

Build, connect, and automate anything — visually.
Self-hosted alternative to n8n and Node-RED, built with Rust + React.

Live Demo • Website • Community • Quick Start

Why z8run?

Most workflow tools are either slow (Node.js), locked-in (SaaS), or hard to extend. z8run is none of those.

z8run is an open-source visual flow engine built from the ground up in Rust for performance, safety, and extensibility. Inspired by tools like Node-RED and n8n, z8run is designed for developers who need real-time automation with a modern stack.

Key principles:

• Fast — Rust + Tokio async runtime, compiled to native code
• Visual — Drag-and-drop node editor with real-time WebSocket sync
• Extensible — WebAssembly plugin sandbox (write plugins in any language that compiles to WASM)
• Lightweight — Single binary, embedded SQLite, zero external dependencies to get started
• Secure — AES-256-GCM credential vault, JWT auth, sandboxed plugin execution

Comparison

Quick Start

From Source

Requirements: Rust 1.91+, Node.js 22+ and npm (for frontend)

git clone https://github.com/z8run/z8run.git
cd z8run
cp .env.example .env          # adjust as needed
cargo build --release
cargo run --bin z8run -- serve

With Docker

git clone https://github.com/z8run/z8run.git
cd z8run
cp .env.example .env          # set Z8_JWT_SECRET and POSTGRES_PASSWORD
docker compose up -d

Pre-built images are available on GHCR:

docker pull ghcr.io/z8run/z8run-api:latest
docker pull ghcr.io/z8run/z8run-nginx:latest

The server starts on http://localhost:7700.

Test the API

# Health check
curl http://localhost:7700/api/v1/health

# Create a flow
curl -X POST http://localhost:7700/api/v1/flows \
  -H "Content-Type: application/json" \
  -d '{"name": "My First Flow"}'

# List all flows
curl http://localhost:7700/api/v1/flows

Architecture

z8run is organized as a Rust workspace with focused crates:

z8run/
├── crates/
│   ├── z8run-core       # Flow engine, DAG validation, scheduler, 23 built-in nodes
│   ├── z8run-protocol   # Binary WebSocket protocol (11-byte header)
│   ├── z8run-storage    # SQLite / PostgreSQL persistence layer
│   ├── z8run-runtime    # WASM plugin sandbox (wasmtime)
│   └── z8run-api        # REST + WebSocket server (Axum)
├── bins/
│   ├── z8run-cli        # Main CLI binary
│   └── z8run-server     # Server with embedded frontend
├── frontend/            # React + TypeScript visual editor
│   ├── src/features/    # Editor canvas, node palette, config panel
│   ├── src/stores/      # Zustand state management
│   └── src/lib/         # Node definitions, utilities
└── Cargo.toml           # Workspace root

How it works

1. Flows are directed acyclic graphs (DAGs) of nodes connected by typed ports
2. Nodes process messages and pass them to connected outputs
3. The scheduler compiles flows into parallel execution plans using topological ordering
4. Plugins run inside a WebAssembly sandbox with controlled capabilities (network, filesystem, memory limits)
5. The protocol uses a compact binary format over WebSockets for real-time editor sync

CLI

z8run serve                            # Start the server (default port 7700)
z8run serve -p 8080                    # Custom port
z8run migrate                          # Run database migrations
z8run plugin list                      # List installed plugins
z8run plugin install ./csv-parser.wasm # Install a plugin from .wasm file
z8run plugin install ./json-transform/ # Install from directory with manifest.toml
z8run plugin remove csv-parser         # Uninstall a plugin by name
z8run plugin scan                      # Scan plugin directory
z8run validate flow.json               # Validate a flow file
z8run info                             # Show system information

Environment Variables

API

REST Endpoints

WebSocket

Connect to ws://localhost:7700/ws/engine for real-time communication using the z8run binary protocol.

Built-in Nodes

z8run ships with 23 native nodes across 6 categories:

Roadmap

• [x] Core engine with DAG validation and topological scheduling
• [x] Binary WebSocket protocol
• [x] REST API (Axum 0.8)
• [x] SQLite / PostgreSQL persistence
• [x] Visual node editor (React Flow + Zustand + Tailwind)
• [x] 23 built-in nodes (HTTP In/Out/Request, Debug, Function, Switch, Filter, Delay, Timer, Webhook, JSON Transform, Database, MQTT + 10 AI nodes)
• [x] Real-time WebSocket execution events
• [x] Namespaced hook routes (/hook/{flow_id}/{path})
• [x] Smart config UI (dropdowns, password fields, code editors)
• [x] Multi-database support (PostgreSQL, MySQL, SQLite)
• [x] Flow management UI (list, create, delete from browser)
• [x] Deploy & test from UI (save, deploy, stop buttons)
• [x] Authentication & multi-user (JWT + argon2)
• [x] Credential vault (AES-256-GCM encrypted connections)
• [x] Flow import/export (JSON)
• [x] WASM plugin execution (wasmtime sandbox with capabilities)
• [x] MQTT node (publish/subscribe with TLS)
• [x] AI suite: LLM, Embeddings, Classifier, Prompt Template, Text Splitter, Vector Store, Structured Output, Summarizer, AI Agent, Image Gen
• [x] Docker deployment (multi-stage build, GHCR registry)
• [x] CI/CD pipeline (GitHub Actions: build, test, deploy, release)
• [x] Domain setup with Cloudflare (landing + app subdomains)
• [x] Plugin install/remove CLI (z8run plugin install, z8run plugin remove)
• [ ] Undo/redo in the flow editor
• [ ] Flow duplication
• [ ] Node search/filter in the palette
• [ ] Rate limiting on the API
• [ ] Integration tests
• [ ] MySQL storage adapter
• [ ] Plugin marketplace
• [ ] Helm chart for Kubernetes

Contributing

z8run is in early development. Contributions, ideas, and feedback are welcome!

1. Fork the repository
2. Create your feature branch (git checkout -b feature/amazing-feature)
3. Commit your changes (git commit -m 'Add amazing feature')
4. Push to the branch (git push origin feature/amazing-feature)
5. Open a Pull Request

Security

If you discover a security vulnerability, please email [email protected] instead of opening a public issue. We take security seriously and will respond promptly.

License

z8run is dual-licensed under Apache 2.0 and MIT. You may choose either license.

Support

• Website: z8run.org
• Email: [email protected]
• GitHub Issues: z8run/z8run/issues
• Sponsor: GitHub Sponsors

Built with Rust and a lot of coffee.

If you find z8run useful, please consider giving it a star on GitHub — it helps others discover the project.