https://github.com/martin98-afk/canvasmind
A modern low-code visual programming IDE built on NodeGraphQt and qfluentwidgets, supporting drag-and-drop component orchestration, asynchronous execution, file operations, loop control, and one-click export of workflows into standalone runnable projectsโenabling seamless transition from development to deployment.
https://github.com/martin98-afk/canvasmind
nodegraphqt pyqt-fluent-widgets
Last synced: 3 days ago
JSON representation
A modern low-code visual programming IDE built on NodeGraphQt and qfluentwidgets, supporting drag-and-drop component orchestration, asynchronous execution, file operations, loop control, and one-click export of workflows into standalone runnable projectsโenabling seamless transition from development to deployment.
- Host: GitHub
- URL: https://github.com/martin98-afk/canvasmind
- Owner: martin98-afk
- License: gpl-3.0
- Created: 2025-09-27T07:34:23.000Z (5 months ago)
- Default Branch: master
- Last Pushed: 2026-01-31T18:32:56.000Z (25 days ago)
- Last Synced: 2026-01-31T22:59:45.751Z (25 days ago)
- Topics: nodegraphqt, pyqt-fluent-widgets
- Language: Python
- Homepage: https://canvasmind-sphinx-build.readthedocs.io/zh-cn/latest/
- Size: 629 MB
- Stars: 67
- Watchers: 3
- Forks: 14
- Open Issues: 5
-
Metadata Files:
- Readme: README.md
- License: LICENSE.txt
Awesome Lists containing this project
README
Visual Programming Platform for Algorithm & AI Workflow Development
[๐จ๐ณ ไธญๆ](README_zh.md) | [๐ฌ๐ง English](README.md) | [๐ Documentation](https://canvasmind-sphinx-build.readthedocs.io/zh-cn/latest/) | [b็ซ็ธๅ
ณไป็ป่ง้ข](https://www.bilibili.com/video/BV153zCBGEU2?spm_id_from=333.788.videopod.sections&vd_source=730f7f3382f460e22f17a3b2c58f0256)
A modern low-code visual programming platform built on **NodeGraphQt** and **qfluentwidgets**, supporting drag-and-drop component orchestration, asynchronous execution, file operations, control flow logic, and one-click export of workflows into standalone, executable projectsโenabling seamless transition from development to deployment.
---
## ๐ Why Choose CanvasMind?
| Traditional Low-Code Tools | CanvasMind |
|---------------------------|-----------|
| Static component assembly | **Dynamic expressions + global variables** drive parameters |
| Only serial execution | Full **conditional branching, iteration, and loops** |
| No custom logic | **Embedded code editor** for writing Python components freely |
| Execution = endpoint | **One-click export** to standalone projects (API, CLI, Docker) |
| AI disconnected from canvas | **Deep LLM integration**: yellow jump / purple create buttons for canvas-aware intelligent completion |
| Fixed Runtime Environment | Supports remote execution via SSH: Features integrated Python environment management for SSH servers and supports dispatching nodes to the server-side for execution. |
---
## ๐ Key Features
### ๐จ Modern UI
- **Fluent Design** โ Built with `qfluentwidgets` for a polished, native look
- **Dark Theme** โ Eye-friendly dark mode by default
- **Responsive Layout** โ Adapts to various screen sizes
### ๐งฉ Visual Programming
- **Drag-and-Drop Nodes** โ Drag components from the panel onto the canvas
- **Dataflow Connections** โ Connect output and input ports to define dependencies
- **Backdrop Grouping** โ Visually group related nodes using Backdrop nodes
- **Context Menus** โ Full right-click menu for node operations
### โก Distributed & Hybrid Execution Engine
* **Parallel DAG Execution** โ Independent branches are executed concurrently via a high-performance task scheduler, maximizing CPU/GPU utilization across the workflow.
* **Hybrid Runtime Orchestration** โ Supports seamless mixing of execution environments:
* **Interactive IPython Kernel**: Leveraging local persistent sessions for rapid debugging and state retention.
* **Remote SSH Workers**: Transparently dispatching heavy-compute nodes (e.g., Model Training/Inference) to high-performance servers with automated environment syncing.
* **Selective In-Memory Persistence (Caching)** โ Users can toggle "Pin to Memory" for specific nodes; results are cached in the active process RAM to eliminate redundant re-computation and I/O overhead during iterative tuning.
* **Intelligent Topological Dispatch** โ Automatically resolves dependencies and routes tasks to the optimal target (Local/Remote/IPython) based on node configuration.
* **Unified State Management** โ Real-time visualization of node status (Queued / Running / Success / Failed) across all distributed workers on a single canvas.
* **High-Speed Data Serialization** โ Utilizes `pyarrow` and `pickle` for low-latency data transfer between local and remote environments.
### ๐ง Intelligent Node Recommendation โจ
- **Type-Aware Suggestions** โ Automatically match compatible downstream components based on output port types
- **Multi-Port Grouping** โ Recommendations grouped by source port for clarity
- **Visual Differentiation** โ Color-coded suggestions per port type
- **Cross-Canvas Learning** โ Tracks component connection frequency to improve recommendations over time
### ๐ค LLM-Canvas Context Integration (โ
Implemented)
- **Yellow Jump Buttons**: When the LLM references an existing node, a yellow `[Node Name](jump)` button appearsโclick to instantly navigate to that node on the canvas.
- **Purple Create Buttons**: When recommending a new capability, a purple `[Component Name](create)` button is generatedโclick to instantiate the component from your library and auto-connect it.
- **Multimodal Context Injection**: Automatically passes node JSON, variable states, and base64-encoded images to the LLM for precise, actionable suggestions.
- **Canvas-Aware Completion**: Supports simultaneous references to multiple existing nodes (yellow) and recommendations for missing components (purple), enabling end-to-end workflow completion.
### ๐ Advanced Control Flow โจ
- **Conditional Branching** โ Enable/disable branches based on `$...$` expressions (`if/else` logic)
- **Iteration** โ Loop over lists or arrays, executing subgraphs per element
- **Loop Control** โ Fixed-count or condition-driven loops
- **Dynamic Subgraph Skipping** โ Entire downstream subgraphs of inactive branches are skipped for efficiency
- **Expression-Driven Logic** โ Branch conditions, loop counts, etc., support dynamic expressions
### ๐ Global Variables & Expression System โจ
- **Structured Scopes** โ Three variable scopes: `env` (environment), `custom` (user-defined), and `node_vars` (node outputs)
- **Dynamic Expressions** โ Use `$env_user_id$` or `$custom_threshold * 2$` in any parameter field
- **Runtime Evaluation** โ Expressions resolved before execution, with support for nested dicts/lists
- **Secure Sandbox** โ Powered by `asteval`; prevents unsafe operations and isolates environments via `contextmanager`
- **UI Integration** โ Select variables or type expressions directly in component property panels
### โ
Dynamic Code Components
- **Full Python Logic** โ Write complete `run()` methods and helper functions inside nodes
- **Dynamic Ports** โ Add/remove input/output ports via UI; bind global variables as defaults
- **Full Feature Integration** โ Leverages global variables, expressions, auto-dependency install, logging, and status visualization
- **Safe Execution** โ Runs in isolated subprocesses with timeout control, error capture, and retry support
- **Developer-Friendly Editor** โ Professional code editor with dark theme, syntax highlighting, intelligent autocomplete, folding, and error diagnostics
### ๐ Node Management
- **Dynamic Loading** โ Auto-scans `components/` directory and loads new components
- **Pydantic Schemas** โ Define inputs, outputs, and properties using Pydantic models
- **Per-Node Logging** โ Each node maintains its own execution log
- **State Persistence** โ Save/load entire workflows
- **Auto Dependency Resolution** โ Components declare `requirements`; missing packages are auto-installed at runtime
### ๐ฆ Model Export & Standalone Deployment โจ
- **Subgraph Export** โ Select any group of nodes and export as a self-contained project
- **Train/Inference Separation** โ Export only inference logic with trained models bundled
- **Zero-Dependency Runtime** โ Generated project runs independentlyโno CanvasMind required
- **Multi-Environment Support** โ Auto-generated `requirements.txt` enables deployment to servers, Docker, or CLI environments
### ๐ ๏ธ Exported Project Tool Integration
- **Direct Invocation** โ Canvas can call exported project scripts by name and retrieve results
- **Parameter Passing** โ Node properties define tool-call parameters, passed automatically at runtime
- **Full Logging** โ Detailed logs of tool execution are captured and returned for debugging
- **LLM Function Calling Ready** โ Standardized tool name, input/output schema, and examples for seamless LLM integration
---
## ๐ Quick Start
### Requirements
- Python 3.8+
- PyQt5 or PySide2
### Install Dependencies
```bash
pip install -r requirements.txt
```
### Run the Application
```bash
python main.py
```
### Package with PyInstaller
```bash
pyinstaller --onedir --windowed --add-data "app;app" --add-data "icons;icons" -i icons/logo3.png main.py
```
---
## ๐งช Component Development
### Supported Port Types
| Type | Description | Example |
|-------------------|---------------------|---------------------------|
| `TEXT` | Text input | String parameters |
| `LONGTEXT` | Long text input | Multi-line strings |
| `INT` | Integer | Numeric values |
| `FLOAT` | Floating point | Decimal numbers |
| `BOOL` | Boolean | Toggle switches |
| `CSV` | CSV list data | Column selections |
| `JSON` | JSON structure | Dynamic nested data |
| `EXCEL` | Excel data | Cell ranges |
| `FILE` | File path | Local file reference |
| `UPLOAD` | Document upload | User-uploaded files |
| `SKLEARNMODEL` | Scikit-learn model | Trained `.pkl` models |
| `TORCHMODEL` | PyTorch model | `.pt` or `.pth` models |
| `IMAGE` | Image data | Base64 or file paths |
### Supported Property Types
| Type | Description | Example |
|-----------------|-----------------|------------------------|
| `TEXT` | Text input | Short strings |
| `LONGTEXT` | Long text input | Code snippets, prompts |
| `INT` / `FLOAT` | Numeric input | Thresholds, counts |
| `BOOL` | Toggle | Enable/disable flags |
| `CHOICE` | Dropdown | Predefined options |
| `DYNAMICFORM` | Dynamic form | Variable-length lists |
| `RANGE` | Numeric range | Min/max sliders |
| `VARIABLE` | variable selector | global_variable |
| `FILE SELECT` | Select file | canvas_files/model.pth |
---
## ๐ฎ Canvas Usage Guide
### Basic Operations
1. **Create Node** โ Drag from left panel to canvas
2. **Connect Nodes** โ Drag from output port to input port
3. **Run Node** โ Right-click โ โRun This Nodeโ
4. **View Logs** โ Right-click โ โView Node Logsโ
### Advanced Features
- **Loops** โ Use Loop/Iterate nodes with Backdrop for structured iteration
- **File Handling** โ Click file picker in property panel
- **Workflow Management** โ Save/load via top-left buttons
- **Node Grouping** โ Select multiple nodes โ right-click โ โCreate Backdropโ
- **Dependency Management** โ Failed components auto-install missing `requirements`
### Keyboard Shortcuts
- `Ctrl+R` โ Run workflow
- `Ctrl+S` โ Save workflow
- `Ctrl+O` โ Load workflow
- `Ctrl+A` โ Select all nodes
- `Del` โ Delete selected nodes
---
## ๐ ๏ธ Development Notes
### Node Status Colors
- **Idle** โ Gray border
- **Running** โ Blue border
- **Success** โ Green border
- **Failed** โ Red border
### Connection Line Colors
- **Idle** โ Yellow
- **Input Active** โ Blue
- **Output Active** โ Green
### Logging System
- Each node has independent logs with timestamps
- Powered by **Loguru** โ use `self.logger` in components
- All `print()` output is automatically captured
### Dataflow
- Inputs auto-populated from upstream outputs
- Outputs stored by port name
- Full multi-input/multi-output support
---
## ๐ฅ Model Export (Standalone Deployment)
### Core Value
Export **any subgraph as a self-contained project** that runs in any Python environmentโno CanvasMind required.
### Use Cases
- **Train/Inference Split** โ Export only inference logic with models bundled
- **Team Sharing** โ Share full workflows as runnable projects
- **Production Deployment** โ Run on servers or in Docker
- **Offline Execution** โ CLI-only environments
### Export Features
โ
**Smart Dependency Analysis** โ Copies only necessary component code
โ
**Path Rewriting** โ Model/data files copied and converted to relative paths
โ
**Column Selection Preserved** โ CSV column config fully retained
โ
**Environment Isolation** โ Auto-generated `requirements.txt`
โ
**Ready-to-Run** โ Includes `run.py` and `api_server.py`
### Export Steps
1. **Select Nodes** โ Choose any nodes on canvas (multi-select supported)
2. **Click Export** โ Top-left **โExport Modelโ** button (๐ค icon)
3. **Choose Directory** โ Project folder auto-generated
4. **Run Externally**:
```bash
# Install dependencies
pip install -r requirements.txt
# Run model
python run.py
```
### Exported Project Structure
```
model_xxxxxxxx/
โโโ model.workflow.json # Full workflow definition (nodes, connections, column selections)
โโโ project_spec.json # Input/output schema
โโโ preview.png # Canvas preview snapshot
โโโ README.md # Project overview
โโโ requirements.txt # Auto-analyzed dependencies
โโโ run.py # CLI entrypoint
โโโ api_server.py # FastAPI microservice
โโโ scan_components.py # Component loader
โโโ runner/
โ โโโ component_executor.py
โ โโโ workflow_runner.py
โโโ components/ # Original component code (preserved structure)
โ โโโ base.py
โ โโโ your_components/
โโโ inputs/ # Bundled models/data files
```
---
## ๐ Feature Status (โ
Implemented | โณ Planned)
- โ
Visual canvas (NodeGraphQt)
- โ
Control flow: conditionals, loops, iteration
- โ
Global variables + expression system
- โ
Dynamic code components (embedded editor)
- โ
Intelligent node recommendations
- โ
One-click export (CLI + API)
- โ
Multi-environment management
- โ
**LLM context integration (yellow jump / purple create buttons)**
- โ
Parallel & remote execution
- โณ Code-to-canvas auto-creation (from editor โ new node)
---
## ๐ค Contributing
1. Fork the repository
2. Create your feature branch (`git checkout -b feature/AmazingFeature`)
3. Commit your changes (`git commit -m 'Add some AmazingFeature'`)
4. Push to the branch (`git push origin feature/AmazingFeature`)
5. Open a Pull Request
---
## ๐ License
This project is licensed under the [GPLv3 License](LICENSE).
---
## ๐ Acknowledgements
- [NodeGraphQt](https://github.com/jchanvfx/NodeGraphQt) โ Node graph framework
- [PyQt-Fluent-Widgets](https://github.com/zhiyiYo/PyQt-Fluent-Widgets) โ Fluent Design UI library
- [Loguru](https://github.com/Delgan/loguru) โ Elegant Python logging
## Star History
