Cerulion Graph Editor
Visual programming for real-time systems. Build data pipelines by connecting nodes—the framework generates all communication code so you can focus on your business logic.Try the Quickstart
Build your first graph in 10 minutes. Create a working pipeline from scratch.
60-Second Mental Model
Cerulion Graph Editor lets you design how data flows, not how components talk. You visually connect computation units (nodes) with typed data channels (topics). From that graph, Cerulion generates all the glue code required to move data efficiently and safely at runtime.
In practice:
- You design a graph visually
- You define data schemas once
- You write node logic only
- Cerulion generates and runs everything else
What is Cerulion Graph Editor?
Cerulion Graph Editor is a visual programming platform for designing data pipelines and workflows by connecting nodes on a canvas. Instead of writing glue code to connect components, you create a graph by placing nodes and connecting them with typed data channels called topics.Core Concept
Each node represents a computation unit (similar to a function or service) that processes incoming data and emits outputs. Nodes expose input and output ports, which you connect visually using links. The editor automatically generates all framework code required to run your graph, handling low-level concerns such as:- Message serialization
- Transport and routing
- Type validation
- Execution scheduling
Key Differentiator
Focus on business logic, not wiring.
You write the computation logic for each node. Cerulion handles communication, type safety, and execution.If you’ve used tools like Node-RED or LabVIEW, the concept will feel familiar—but Cerulion is built specifically for high-performance, real-time data processing, with first-class support for Rust, Python, and C++.
You write the computation logic for each node. Cerulion handles communication, type safety, and execution.If you’ve used tools like Node-RED or LabVIEW, the concept will feel familiar—but Cerulion is built specifically for high-performance, real-time data processing, with first-class support for Rust, Python, and C++.
Hello World: A Minimal Graph
A typical first graph looks like this:
Example flow:
- A source node publishes data
- A processor node transforms it
- A sink node consumes or displays the result
How It Works
Cerulion Graph Editor follows a clear lifecycle from design to execution.
1
Design Your Graph
Place nodes on the canvas and define their inputs and outputs. Each node represents a computation unit in your pipeline. This is your system architecture.
2
Define Schemas
Define type-safe message schemas that flow between nodes. Schemas ensure every component agrees on data structure and enable compile-time validation.
3
Connect Nodes
Draw links between node ports to create data paths. The editor enforces type compatibility—you can only connect matching schemas.
4
Write Node Logic
Implement node behavior in Rust, Python, or C++. You write only the computation logic; the framework handles messaging, serialization, and transport.
5
Generate & Run
Cerulion generates all framework code and runs your pipeline. You can observe execution and inspect data flowing through each node in real time.
Why Use Cerulion Graph Editor?
Cerulion Graph Editor is designed to make complex data-flow systems easier to build, reason about, and evolve.Development Experience
Visual Architecture
See your system architecture and data flow at a glance. Understand how components interact without tracing code paths.
Auto Code Generation
Eliminate boilerplate and glue code. Cerulion generates communication and execution code automatically.
Modular Design
Rewire and refactor visually. Add, remove, or rearrange components without rewriting infrastructure code.
Type Safety and Performance
Type-Safe Messaging
Typed topics prevent incompatible connections and catch data errors before execution.
Multi-Language Support
Combine Rust, Python, and C++ nodes in the same graph. Use each language where it fits best.
Real-Time Performance
Built on Cerulion Core for low-latency execution, zero-copy local transport, and efficient networking.
Key Concepts at a Glance
These core concepts form the foundation of every Cerulion graph.Core Components
Nodes
Execution units that run code when data arrives. Nodes expose input and output ports. Learn more →
Topics
Typed data channels that connect nodes and enforce schema compatibility. Learn more →
Data and Connections
Schemas
Structured data definitions (YAML) shared across nodes to guarantee consistent data formats. Learn more →
Ports & Links
Ports define inputs and outputs; links connect them to form data paths. Learn more →
Execution Control
When to Use Cerulion Graph Editor
Cerulion Graph Editor is ideal when data flow and performance matter.Ideal Use Cases
- Real-time data processing — Low-latency pipelines and immediate responses
- Inspectable architectures — Visual graphs make systems easier to understand and debug
- Performance-oriented messaging — Efficient, zero-copy data paths
- Rapid iteration — Rewire pipelines without rewriting glue code
- Mixed-language systems — Combine Rust, Python, and C++ components
When to Consider Alternatives
Prerequisites
You don’t need deep expertise to get started.Recommended Background
- Basic programming concepts — Functions, inputs/outputs, variables
- One supported language — Rust, Python, or C++
- Familiarity with data structures — Structs, classes, fields
These are recommendations, not requirements. The Quickstart is designed to be approachable even if you’re new to parts of the stack.