Generate and Run
Once you’ve designed your graph, you need to generate the framework code and run it. This guide walks you through generating code from your visual graph and executing your pipeline.Prerequisites
Before you begin, make sure you have:Graph Designed
A complete graph with nodes, ports, and connections. See Quickstart if needed.
Node Code Written
All nodes have implementation code written. See Write Node Code if needed.
Schemas Valid
All schemas are valid and error-free. Check the schemas panel for validation errors.
Build Tools Installed
Required build tools for your node languages (Rust compiler, Python interpreter, C++ compiler).
Code generation creates the framework code that handles communication between nodes. Your node code is integrated into this framework automatically.
What You’ll Do
You’ll:- Generate framework code from your graph design
- Build the generated code
- Run your pipeline
- Monitor execution and output
Step-by-Step Guide
1
Validate your graph
Before generating, ensure your graph is valid:
- All nodes have code - No empty node implementations
- All connections are valid - Port types match
- All schemas are valid - No schema errors
- No circular dependencies - Graph doesn’t have problematic loops
Check the console for any validation errors. Fix them before generating.
2
Generate code
Click Generate in the toolbar (or press
Ctrl+G / Cmd+G).You should see:
- Progress indicator showing code generation
- Console output with generation status
- “Generation complete” message when done
Code generation creates:
- Framework code for node communication
- Build configuration files
- Type definitions from schemas
- Integration code for your node implementations
3
Review generation output
Check the console for generation results:
- Success - “Code generation completed successfully”
- Warnings - Non-critical issues (review but may not block execution)
- Errors - Critical issues that must be fixed
If generation succeeded, you should see build files created in your project directory.
4
Build the project
The framework will automatically build your project:
- Rust nodes - Compiled with
cargo build - Python nodes - Checked for syntax errors
- C++ nodes - Compiled with your C++ compiler
Watch the build output in the console. You should see compilation progress.
The first build may take several minutes as dependencies are downloaded and compiled. Subsequent builds are faster.
5
Verify build success
Check that the build completed successfully:
- No compilation errors - All code compiled
- Binaries created - Executables generated
- Dependencies resolved - All required libraries found
You should see “Build completed successfully” in the console.
6
Run your graph
Click Run in the toolbar (or press
Ctrl+R / Cmd+R).You should see:
- Graph execution starting
- Node output in the console
- Status indicators showing running nodes
The framework starts all nodes and begins processing data. Nodes execute when data arrives on their trigger inputs.
7
Monitor execution
Watch the console and status indicators:
- Console output - Print statements from your nodes
- Status indicators - Which nodes are running
- Performance metrics - Execution times and throughput
You should see data flowing through your pipeline, with output from subscriber nodes appearing in the console.
8
Stop execution (when done)
Click Stop in the toolbar (or press
Ctrl+Shift+R / Cmd+Shift+R) to stop the graph.All nodes should stop executing, and the graph should return to edit mode.
Understanding the Process
Code Generation
Code generation creates:- Framework code - Handles node communication and data flow
- Type definitions - Generated from your schemas
- Build configuration - Compiler flags and dependencies
- Integration code - Connects your node code to the framework
Building
Building compiles:- Rust nodes - Into native binaries
- Python nodes - Validated and packaged
- C++ nodes - Into object files and linked
- Framework - Communication and runtime code
Running
Running executes:- All nodes - Started in parallel
- Data flow - Messages flow through topics
- Node execution - Triggered by incoming data
- Output - Results appear in console or output files
Common Workflow
The typical development workflow:- Design - Create nodes and connections in the editor
- Code - Write node implementation code
- Generate - Generate framework code
- Build - Compile everything
- Run - Execute and test
- Debug - Fix issues and iterate
- Repeat - Make changes and regenerate
Troubleshooting
Generation fails
Generation fails
Problem: Code generation fails with errors.Solutions:
- Check for validation errors in your graph
- Verify all schemas are valid
- Ensure all nodes have code written
- Check for circular dependencies
- Review console output for specific error messages
Build fails
Build fails
Problem: Code compiles but build fails.Solutions:
- Check that build tools are installed (Rust, Python, C++ compiler)
- Verify dependencies are available
- Check for syntax errors in node code
- Review build output for specific error messages
- Try cleaning and rebuilding:
cargo clean(for Rust)
Graph won't run
Graph won't run
Problem: Build succeeds but graph doesn’t start.Solutions:
- Check console for runtime errors
- Verify all required dependencies are available
- Check that nodes are properly configured
- Look for port type mismatches
- Verify schemas are loaded correctly
No output
No output
Problem: Graph runs but produces no output.Solutions:
- Check that publisher nodes are actually sending data
- Verify connections are correct
- Check trigger configuration (nodes may not be executing)
- Look for errors in node code that might prevent execution
- Verify subscriber nodes are receiving data
Best Practices
Validate First
Always validate your graph before generating. Fix errors early.
Incremental Development
Generate and test frequently. Don’t wait until everything is perfect.
Monitor Output
Watch console output during execution. It helps catch issues early.
Clean Builds
If you encounter strange build issues, try a clean build.