NodeTool

The open creative AI workspace.

Every model. Your keys. Your canvas.

NodeTool is the open-source creative AI workspace — every major model from every major provider, called with your own keys, wired into one node-based canvas you run on your machine.

Bring your own keys to FAL, KIE, Atlas, OpenAI, Anthropic, Gemini, Replicate, ElevenLabs, HuggingFace. Pay providers directly at provider prices. Switch the moment a better model ships. Wire it all into one canvas with the editing tools you rely on — masks, inpaint, outpaint, relight, upscale, layers, compositing.

Contents

• Why NodeTool
• What's in the box
• What people build with it
• Video editor
• Sketch editor
• Models
• How NodeTool compares
• Get NodeTool
• Documentation
• CLI & Server (npm)
• Architecture
• Development Setup
• Testing
• Contributing
• License

Why NodeTool

The best model for the job changes every month. NodeTool keeps up.

Seedance is the best video model right now. It's available on FAL, Replicate, and KIE at different price points. NodeTool lets you pick the cheapest. When Veo 4 ships, you swap one node and you're on it the same day.

That's what vendor neutrality buys you:

• Every model. OpenAI, Anthropic, Gemini, FAL, KIE, Replicate, ElevenLabs, HuggingFace. Local with Ollama, MLX, and GGUF.
• Your keys. Pay providers directly at provider prices. No credit markup, no proprietary tokens.
• Your canvas. Workflows, files, and keys belong to you. Everything runs on your machine.
• Open source. AGPL-3.0. Self-host any time. No acquisition risk.

What's in the box

What people build with it

The workspace is a canvas, not a wizard. A few of the patterns we see most often:

• Image generation and editing — FLUX.2, Nano Banana Pro, GPT-Image 3, plus mask, inpaint, outpaint, relight, and upscale as first-class nodes.
• Video — Seedance, Sora 2 Pro, Veo 3.1, Wan 2.6, Hailuo 2.3, Kling 2.6. Text-to-video, image-to-video, and video-to-video pipelines, cut together on a multi-track timeline.
• Voice and audio — Whisper for transcription, ElevenLabs and OpenAI TTS for speech, audio analysis and editing as nodes.
• Document search — point a workflow at a folder, embed it, query it. RAG without writing the plumbing.
• Multi-step agents — agents are a capability inside the workspace, not a separate product. Wire one into a graph when a step needs to plan, decide, or call tools.
• Mini-apps — share a workflow as an interactive web app others can run.

Video editor

A generation-aware, multi-track timeline lives right next to the canvas. Drop in your own footage or bind a workflow to a clip — a text-to-image, image-to-video, or text-to-speech pipeline — and generate it in place. Change a parameter and the clip regenerates; tweak the bound workflow and the clip flags itself stale. Composite a live preview across video, audio, and overlay tracks, then export the whole sequence to MP4.

See the Video Editor guide for the full tour.

Sketch editor

A layered paint canvas built into the node graph. Draw and paint with real brushes, build up a composition in layers with blend modes and masks, then bind a layer to a model or one of your own workflows and generate image content right where you're painting. Change a prompt or an upstream input and the layer flags itself stale; regenerate in place and keep working on top. When you're done, the node hands the rest of your workflow a flattened image, a mask, and per-layer outputs — no export/import round-trip. It pairs naturally with the editing nodes (mask, inpaint, outpaint, compositing) for sketch-then-generate pipelines.

See the Sketch Editor guide for tools, layers, AI generation, and keyboard shortcuts.

Models

Pick a provider per node. Switch by changing one field.

Use TextToVideo, ImageToVideo, or TextToImage nodes and select your provider and model. Some models route through kie.ai, which combines providers and is often the cheapest path.

How NodeTool compares

vs ComfyUI. ComfyUI exposes every parameter for engineers who want them. NodeTool keeps the node-based power, gives it an interface that doesn't fight you, and covers the rest of the stack — video, audio, text, document search.

vs Weavy. Weavy was the closed-source canvas for creative AI. After the Figma acquisition, the roadmap belongs to someone else. NodeTool is the open alternative — same node-based canvas, your keys, your files, no acquisition risk.

vs n8n. n8n is for business workflows and API plumbing. NodeTool is built for creative work — models, masks, layers, video, audio, RAG.

Get NodeTool

Download the desktop app, install, and start building — runs fully on your machine.

Flatpak CI Builds are available for Linux.

Documentation

• Getting Started — Build your first workflow
• Video Editor — Sequence and AI-generate clips on a timeline
• Sketch Editor — Draw, mask, and AI-generate on a layered canvas
• Node Packs — Available nodes and integrations
• Custom Nodes — Extend NodeTool
• Deployment — Share your work
• API Reference — Programmatic access

CLI & Server (npm)

Run the server, execute workflows, or chat from the terminal:

# Install globally (Node.js 22.x required)
npm install -g @nodetool-ai/cli

# Start the API server (port 7777)
nodetool serve

# Interactive chat with agent mode
nodetool-chat --agent --provider anthropic --model claude-sonnet-4-6

# Run a TypeScript DSL workflow
nodetool workflows run my-workflow.ts

# One-off without global install
npx --package=@nodetool-ai/cli nodetool serve
npx --package=@nodetool-ai/cli nodetool-chat --agent

See the CLI Reference for all commands.

Architecture

NodeTool is a monorepo with a TypeScript backend, React frontend, Electron desktop shell, and React Native mobile app.

nodetool/
├── packages/          # Backend monorepo (55 packages)
│   ├── kernel/        #   Workflow graph & runner
│   ├── node-sdk/      #   BaseNode class & node registry
│   ├── base-nodes/    #   100+ built-in node types
│   ├── agents/        #   Agent system with task planning & tools
│   ├── runtime/       #   Processing context & model providers
│   ├── websocket/     #   HTTP + WebSocket server (entry point)
│   ├── vectorstore/   #   SQLite-vec vector database
│   ├── code-runners/  #   Sandboxed code execution
│   └── ...            #   Protocol, config, auth, storage, deploy, etc.
├── web/               # React frontend (Vite + MUI + React Flow)
├── electron/          # Electron desktop app
├── mobile/            # React Native mobile app (Expo)
└── docs/              # Jekyll documentation site

For a detailed architecture overview, see ARCHITECTURE.md.

Development Setup

Prerequisites: Node.js 22.22.1, npm. Python 3.11 with conda for Python nodes (optional).

Node 22.22.1 is required. Matches Electron 39's embedded Node so dev and the packaged app run on the same Node version. Use nvm use to activate (reads .nvmrc).

Quick Start

nvm use                    # Activate Node 22.22.1 (reads .nvmrc)
npm install
npm run build:packages     # Build all TS packages in dependency order

# Run backend (port 7777) and frontend (port 3000)
# Uses tsx --watch for the backend, so startup skips a full websocket package rebuild.
npm run dev

Python Nodes (optional)

Python nodes (HuggingFace, MLX, Apple integrations) run via the PythonStdioBridge, which spawns a Python worker process that communicates over stdin/stdout. The bridge connects lazily on the first workflow that uses Python nodes — no separate setup is needed for the TypeScript backend.

Electron App

npm run electron

The Electron app auto-detects your active Conda environment. Settings are stored in:

• Linux/macOS: ~/.config/nodetool/settings.yaml
• Windows: %APPDATA%\nodetool\settings.yaml

Native module ABI caveat. Electron 39 bundles its own Node.js (22.22.1) but uses a distinct NODE_MODULE_VERSION (140), so native modules like better-sqlite3 must be compiled against Electron's headers — not system Node, even when the major matches. This is handled automatically by @electron/rebuild, wired into electron/'s postinstall. If you ever see a NODE_MODULE_VERSION mismatch, force a rebuild:

copy

npm --prefix electron run postinstall

Do not use plain npm rebuild — it compiles against system Node's ABI, which will not match Electron's runtime.

Mobile App

cd mobile && npm install && npm start

See mobile/README.md for full setup.

Common Commands

Testing

# Unit tests
cd electron && npm test && npm run lint
cd web && npm test && npm run lint

# Web E2E (needs backend on port 7777)
cd web && npx playwright install chromium && npm run test:e2e

# Electron E2E (requires xvfb on Linux headless)
cd electron && npm run vite:build && npx tsc
cd electron && npx playwright install chromium && npm run test:e2e

For detailed testing documentation, see web/TESTING.md.

Contributing

We welcome bug reports, feature requests, code contributions, and new nodes.

Please open an issue before starting major work so we can coordinate.

Acknowledgements

• @mphermes — Atlas Cloud integration

License

AGPL-3.0

Get in Touch

• General: [email protected]
• Team: [email protected], [email protected]

GitHub | Discord | Website

Star History