Software development is a computational problem that we have mistakenly turned into a memory problem.

V-NOC is a new kind of coding environment. It replaces the archaic file-and-folder system with a logic Graph, moving the burden of "connecting the dots" from the human brain to the computer.

Programming isn't hard because logic is complex; it’s hard because our tools are disorganized. We spend our lives creating "origami" structures—complex folder hierarchies and design patterns—just to force real-world logic onto a flat file system meant for storage, not thinking.

To fix a bug or add a feature today, you are forced to:

• Unwrap the Origami: Dig through layers of facades and folders just to find the actual logic.
• Be the Human Glue: Manually trace function calls, grep logs, and hunt for docs. You are the "linker" because the IDE doesn't actually understand the relationships.
• Mental Compiling: You have to hold a massive map of the project in your head just to change one line.

We spend 10% of our time coding and 90% wrapping and unwrapping structure.

Computers were built to simplify things. If a computer can trace an execution path, a human should never have to.

In math, you don't solve everything at once; you decompose problems into small, verifiable pieces. V-NOC applies this to code. By using a Graph DB (ArangoDB) instead of a file tree, the computer computes the structure for you. You aren't reading a list of files; you are navigating a logic map.

English is the new programming language, but a chat box is the wrong interface for it. Nobody wants to read a 100-message log to understand what an agent did. In V-NOC, agents live on a Canvas.

Instead of reading a text log, you watch an animated walkthrough of the changes.

It’s like Google Maps for your codebase: You interact with words, but the response is a visual map that anyone can understand.

In a traditional IDE, every piece of information is a distraction.

• Need logs? You have to scroll through a messy terminal.
• Need docs? You have to switch to a browser.
• Need the call stack? You have to trigger a debugger.

In V-NOC, everything is already there. Logs, documentation, and code are all part of the same node. You only see what is mathematically necessary for the task at hand. No noise, no accidental complexity.

I want to make programming fun and clear again. If you can read a map, you should be able to read code. V-NOC isn't about hiding the details; it's about simplifying the organization so the details actually make sense.

Graphs are flexible by nature. V‑NOC lets you view and work on your project based on what you need at the moment—whether that’s a high‑level system overview or a deep dive into a single execution path—without moving or restructuring files.

Even in a large codebase, you can isolate and focus on one feature at a time. This is similar to how hardware is repaired: if the power supply fails, you fix the power supply. You don’t need to understand or load the motherboard, RAM, or every other component. You only interact with what’s relevant.

V‑NOC applies the same principle to software. Dependencies are connected and visible, making it easy to isolate a feature, create a sandbox or playground for it, and run or test it independently—manually or with an agent. No unnecessary context, no side quests, just the parts you need to get the job done.

Instead of a file tree, the core of V-NOC is an interactive, multidimensional map.

• The Code is the Database: Your project is stored as nodes (functions, classes) and edges (calls, imports, dependencies).
• Hierarchical Context: Logs follow the code's call graph. You see the "why", "where", and "how" in one view.
• The AI Superpower: We give AI agents the structured context they need. They don't guess; they query the graph, making their work easy to audit.

The tools used in this project were chosen for speed and simplicity, allowing ideas to be prototyped, tested, and shipped quickly. Much of the system is experimental by design, which requires maximum flexibility and minimal friction during development.

I’ve already optimized the codebase as much as reasonably possible, but Python is unforgiving when it comes to performance mistakes. I’ve identified several performance bottlenecks, including in the call‑chain builder, and will continue investigating and optimizing other parts of the system as well.

• Python 3.12+ (uv recommended)
• Node.js 18+ (Yarn recommended)
• Docker (for ArangoDB)

# Create venv and install dependencies
uv venv
make install-backend

make install-frontend

make start-db     # Launch ArangoDB in Docker
make dev          # Start both Backend and Frontend

V-NOC is built for the community. We are moving away from the "chaos of disorganization" toward automated development.

• Join the Discord: discord.gg/J5nfPHqyBr
• License: AGPL-3.0

Interested in contributing? Check our development guide or jump into Discord!