NodeBox is a visual automation platform inspired by [n8n], built for people who want to automate anything with the power of Python.

At its core, NodeBox lets you design workflows on a canvas-like interface, where you can:

• Drag, drop, and connect nodes
• Each node is just Python code: it can receive inputs, process them, and return outputs
• Combine nodes to build simple scripts → advanced multi-step automations

Unlike traditional automation tools that lock you into pre-defined actions, NodeBox gives you the full flexibility of Python — limited only by your creativity.

If you can write Python, you can automate it with NodeBox.

One of the standout features of NodeBox is its deep integration with Ollama. Since much of modern automation relies on AI, NodeBox allows you to:

• Browse Ollama models
• Download & manage models locally
• Integrate LLMs directly into your workflows

This means you can build AI-powered automations without pricey API keys. Everything runs locally, offline, and under your control.

• Automate repetitive tasks
• Build custom AI-driven workflows
• Connect & process data from multiple sources
• Stay private with local execution

We host Weekly NodeBox Community Meetings to discuss updates, ideas, and future plans together. Everyone is welcome to join, share suggestions, and contribute to the growth of NodeBox!

• 🕘 Time: Every Saturday, 9:00 PM – 10:00 PM IST
• 📍 Location: Join on Discord

1. Community Updates: Progress and highlights from the week.
2. Feature Discussions: New ideas and suggestions to improve NodeBox.
3. Open Forum: Share your automation ideas or projects.
4. Q&A Session: Get help, ask questions, and learn from others.
5. Next Week Planning: Define focus areas and contributors for upcoming work.

Follow these steps to set up the application from source:

Are you on Windows? We have a comprehensive, step-by-step guide specifically for Windows users!

Complete Windows Installation & Configuration Guide →

This guide includes:

• Python & Git installation with PATH configuration
• Virtual environment setup with PowerShell execution policy fixes
• Comprehensive Ollama installation and configuration
• Building standalone .exe files with PyInstaller
• Troubleshooting common Windows-specific issues
• Quick reference commands

Recommended for first-time Windows users or anyone encountering setup issues!

Before installing, make sure you have the following installed on your system:

• Python 3.10+ click here
• Ollama click here
• PyQt6 (pip install PyQt6)

git clone https://github.com/shreyansh-shankar/NodeBox.git
cd NodeBox

python -m venv venv

Activate it:

• Linux/Mac:

source venv/bin/activate

• Windows:

venv\Scripts\activate

 pip install -r requirements.txt

• Install Ollama following the official guide
• Run the command in terminal to check installation: ollama --version.
• Run the command: ollama serve. If it starts a server or returns something like ollama is already runniing, you are good to go.

python main.py

All UI resources (fonts, icons, images, stylesheets) are bundled automatically via the included nodebox.spec. To create a distributable build:

1. Activate your virtual environment and install PyInstaller:

   pip install pyinstaller

2. Build the desktop app using the provided spec file (auto-adds assets/, qss/, and data/):

   pyinstaller --clean --noconfirm nodebox.spec

   macOS/Linux users can run the same command from a shell (no changes needed).

3. Launch the packaged app from the generated dist/NodeBox folder (e.g., dist/NodeBox/NodeBox.exe on Windows) and verify that fonts, icons, and model artwork render as expected.

If you prefer invoking PyInstaller without the spec file, make sure every resource folder is passed through --add-data (use ; on Windows, : on Unix-based systems):

pyinstaller --clean --noconfirm --windowed --name NodeBox main.py --add-data "assets;assets" --add-data "qss;qss" --add-data "data;data"

The application now resolves bundled resources via utils.resource_path, so the same paths work in both development and packaged builds.

Follow these steps to build your very first automation inside the app:

- Open the Application – Start the app from your system.
- Browse Models – Head over to the Browse Models section.
- Pick a small model (recommended for first-time setup).
- Click Download.
- Verify Download – Go to View Local Models to ensure the model is installed.
- Create a New Automation – Click New Automation and give it a name.
- Open Automation Editor – Select your automation and click Edit.
- Add a Node – Right-click on the canvas and choose Add Node.
- Edit the Node – Click on the node and click on the open button.
- This will open the Node Editor, where you can write custom Python code.
- Run and test the node to ensure it works as expected.
- Build More Nodes – Add additional nodes (e.g., input, processing, output).
- Connect Nodes – Drag from one node's output port to another's input port to link them.
- Run the Automation – Once connected, click Run to test the complete workflow.
- Debug & Iterate – If something breaks, check node logs and update code accordingly.
- Save Your Work – Don't forget to save your automation for later use.

Tip: Start small (like a text-to-text pipeline) before experimenting with complex multi-node automations.

• Run a local LLM to summarize documents
• Watch a folder and auto-organize files
• Scrape data from websites and process it
• Send notifications when system events occur
• Chain together AI models + traditional scripts

MIT License – free to use, modify, and distribute.