NodeEditor.Net is a visual node editor for .NET 10. It lets you build data-processing and logic graphs by connecting "nodes" together in a browser-based canvas. Each node performs a small operation (add two numbers, format a string, branch on a condition) and the editor handles wiring, execution order, and data flow automatically.
- Application developers who want to add visual programming to their apps
- Tool builders creating no-code/low-code automation interfaces
- Game developers implementing visual scripting (similar to Unreal Blueprints)
- Data engineers building visual data pipelines
- AI developers using MCP to let AI assistants build and execute graphs
NodeEditor.Net is built on .NET 10 and Blazor. It runs on:
- Blazor Server (recommended, full features including dynamic plugins)
- MAUI Blazor Hybrid (Windows, macOS, Android)
- Blazor WebAssembly (no dynamic plugin loading)
- Console/API (headless execution only, no UI)
Yes, NodeEditor.Net is released under the MIT License.
.NET 10 SDK. Download it from dotnet.microsoft.com.
dotnet build NodeEditor.slnxdotnet run --project NodeEditor.Blazor.WebHost/NodeEditor.Blazor.WebHost.csprojThen open https://localhost:5001 (or the port shown in the console) in your browser.
dotnet test NodeEditor.Blazor.Tests/NodeEditor.Blazor.Tests.csprojThis 3-tier architecture separates concerns:
- NodeEditor.Net — Pure .NET core library with no Blazor dependency. Contains models, execution engine, plugins, serialization, and logging. You can use this in console apps, APIs, or any .NET host.
- NodeEditor.Blazor — Razor component library that provides the UI. References NodeEditor.Net and adds Blazor-specific components and services.
- NodeEditor.Blazor.WebHost — A runnable Blazor Server app that wires everything together as a demo.
Yes! The NodeEditor.Net library has no Blazor dependency. You can use HeadlessGraphRunner to execute graphs in console apps, APIs, or background services. See the Headless Execution guide.
It's a DI extension method in NodeEditor.Blazor.Services that registers all required services (state, execution, registry, plugins, serialization, logging, etc.) with their correct lifetimes. Call it once in Program.cs.
- Create a class that implements
INodeContext - Add methods with the
[Node]attribute - Register the assembly with
NodeRegistryService
See the Getting Started Guide and Custom Nodes Tutorial.
- Non-callable (
isCallable: false): Data nodes that compute outputs from inputs. They have no execution flow and evaluate lazily. - Callable (
isCallable: true): Nodes with execution flow sockets (ExecutionPath). They run when their execution input is triggered.
An execution initiator (isExecutionInitiator: true) is a callable node that starts an execution chain. It has no execution input—it's the entry point. Think of it as the "Start" button for a section of your graph.
Yes, node methods can return Task for async operations.
- Copy the
NodeEditor.Plugins.Templateproject - Implement
INodePluginand yourINodeContextclasses - Add a
plugin.jsonmanifest - Build and publish to the plugin repository
See the Plugin SDK.
These platforms don't support dynamic assembly loading (AssemblyLoadContext). On iOS, register plugins at compile time instead:
var registry = serviceProvider.GetRequiredService<NodeRegistryService>();
registry.RegisterFromAssembly(typeof(MyPlugin).Assembly);Open the Plugin Manager (button in the editor toolbar), browse or search for plugins, and click "Install."
Click the "Execute" button in the editor, or programmatically:
var service = serviceProvider.GetRequiredService<NodeExecutionService>();
await service.ExecuteAsync(nodes, connections, context, nodeContext, options, token);- Sequential — Follow execution paths through callable nodes
- Parallel — Run independent data nodes concurrently
Yes, use HeadlessGraphRunner. See Headless Execution.
The Model Context Protocol is a standard for connecting AI assistants to external tools. NodeEditor.Net's MCP server lets AI assistants like Claude and Cursor build and execute node graphs programmatically.
Add to appsettings.json:
{ "Mcp": { "Enabled": true, "RoutePattern": "/mcp" } }Then generate an API key from the Settings panel in the editor.
Yes! In HTTP/SSE mode, the MCP server uses the State Bridge pattern to control the live canvas. When an AI adds a node via MCP, it appears on the user's screen immediately.
Make sure you've registered the assembly:
Registry.EnsureInitialized(new[] { typeof(MyNodes).Assembly });Ensure you call StateHasChanged() in event handlers and always use EditorState.AddNode() instead of directly modifying collections.
Check that:
- The plugin directory exists and contains the DLL
plugin.jsonis present and valid- The plugin's
MinApiVersionis compatible with the host - Check console/logs for detailed error messages
For more troubleshooting, see the Troubleshooting Guide.