Neurite: A Fractal Workspace That Treats Your Notes as a Graph of Thought
Fractal Graph-of-Thought. Rhizomatic Mind-Mapping for Ai-Agents, Web-Links, Notes, and Code.
At a glance
- What is it?
- Neurite is an MIT-licensed JavaScript project that renders the Mandelbrot set as a navigable workspace, then hangs notes, web links, code and AI agent nodes on top of it. The idea is distinctive; the documentation is uneven, and the hard part is figuring out whether the fractal layer earns its place in your workflow.
- Who is it for?
- Adopt Neurite if you already think in graphs and want a local, MIT-licensed workspace where notes, links and agent nodes share one canvas, and you are comfortable reading the repository to fill gaps the README leaves. Do not adopt it if you need a stable, documented note-taking tool for a team, or if you cannot tolerate a UI that the project itself warns contains flashing lights.
- Can I use it commercially?
- Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Activity is slowing. The repository last received commits 6 months ago.
- What is it written in?
- Mainly JavaScript, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on September 15, 2026, and from our analysis. They are not legal advice.
DEEP OPEN-SOURCE ANALYSIS
The Problem Neurite Picks, and Who It Picks It For
Most note tools model a link as a line between two documents. Neurite models the space the documents sit in. The README frames the project as a workspace that blends fractal geometry with mind-mapping, and the stated goal is to grow agentic graphs of fractal creativity and collaboration. Nodes, in that framing, represent text, images, videos, code, and AI agents. So the unit of composition is not the note, it is the node, and a node can be a model rather than a paragraph.
That combination is what separates the target user from the general note-taking audience. If you write linearly and search by keyword, the fractal canvas adds navigation cost without adding retrieval power. If you already keep a Zettelkasten and you have been wiring local models into it, the pitch is narrower and more interesting: one surface where a conversation with an agent, a web link and a code snippet are all addressable positions in the same graph. The README names researchers, writers, artists, developers, educators and curious thinkers, which is broad enough to be unhelpful. The concrete audience is people who want graph search over their own material and are willing to run local servers to get it.
What Actually Renders: Mandelbrot Navigation and Node Physics
The mechanism described in the README has two layers. The lower layer is a real-time fractal renderer. The project claims it can navigate the Mandelbrot set in real time, and the key features table lists the Mandelbrot set, the Burning Ship fractal and the Julia set as selectable, with controls for color, quality and speed, plus a mode that generates the fractal according to your current mouse position. The upper layer is a graph of nodes drawn over that surface. The README states that neurite.network connects physics simulation of graphs with an underlying fractal topology to define interactive, iterative and modular graphs of ideation.
Read that carefully, because it is the whole architecture in one sentence. The fractal is not decoration behind a normal canvas; it is the topology the graph sits on. The README also says that movements through the fractal are no longer interrupted at each step, and that rendering persists and regenerates as you interact. That is a claim about incremental rendering, and it is the reason the fractal is usable as a workspace rather than a screensaver. I cannot confirm from the supplied material how the topology constrains node placement, whether node coordinates are stored as complex-plane positions, or what happens to your layout when you switch from Mandelbrot to Julia. Those are the questions I would answer by reading the source before committing a real archive to it.
FractalGPT and the Multi-Agent Layer
The AI side is described in two feature rows. FractalGPT is called a Zettelkasten AI that responds as a graph of thoughts, and its second row is non-linear memory access: retrieving AI memories and conversation histories non-linearly, with contextual responses that use graph search. The multi-agent row describes connecting and managing multiple AI nodes with collaborative communication between several AI and the user via graph-based multi-agent conversation.
The distinction worth holding onto is between a chat history and a graph of thoughts. A normal assistant retrieves the last N turns or the top-k embedded chunks. A graph-of-thought assistant, as described here, walks edges. That changes failure modes. Retrieval by similarity degrades gracefully: you get a slightly worse passage. Retrieval by graph traversal can return a coherent but wrong branch, because the structure told it the branch was relevant. The README does not describe the traversal policy, the edge weights, or how a node is selected as a starting point, so I cannot tell you how Neurite avoids that. The repository topics list both ollama and rag, which suggests a local model runtime and a retrieval layer, but the README text supplied here does not document the connection. Treat the agent layer as the part to prototype before you trust it.
Synchronized Knowledge and the Zettelkasten Boundary
The synchronized knowledge section is where Neurite makes its most practical promise. Bi-directional sync is described as keeping updates consistent between the fractal mind-mapping workspace and Zettelkasten Archives, so the visual graph and the text notes stay aligned. The README also states that Neurite is not locked into a specific note-taking format, and that you can set custom tags for personalized note headings and reference brackets.
That last detail matters more than it looks. Custom heading tags and reference brackets mean the sync layer is configurable at the syntax level, which is what you need if your archive already uses a convention the tool did not anticipate. The unresolved question is directionality in practice. Bi-directional sync between a free-form spatial canvas and a plain-text archive has to decide what wins when a node is moved, renamed, or deleted on one side. The README does not say. If you point this at an existing Zettelkasten, do it against a copy first, and inspect what the sync actually writes before letting it touch the original. Nothing in the supplied material describes a conflict resolution rule.
Getting It Running: Desktop, Servers, and What the Releases Tell You
The release history is the clearest installation signal available. Three artifacts are listed: Neurite Desktop 2025.06.18.233853 from June 2025, Frontend 2025.05.02.191757 from May 2025, and Localhost Servers 2025.04.12.023909 from April 2025. The split tells you the project ships as an Electron desktop application plus a separately versioned frontend plus a set of local servers. The Neural API section of the README exists but its contents are not in the material supplied here, so I cannot give you endpoint names or request shapes.
The README's own navigation points to a How to Use Neurite section and to demo videos, including a getting-started video linked at the top. That is the honest path: the written setup instructions were not included in the excerpt I have, so the video walkthrough and the release artifacts are what a new user would follow. Two operational notes are visible. First, the README carries a warning that the software contains flashing lights and colors which may affect those with photosensitive epilepsy. That is a real accessibility constraint on the default experience, not a minor disclaimer. Second, the repository topics include ollama and ollama-gui, which points at a local model runtime, so expect the AI features to require something running on your machine rather than a hosted key. Confirm the exact requirement against the repository before you plan around it.
Where Neurite Is the Wrong Tool
The README opens by calling this an open-source project in active development, and the release cadence supports a reading of the project as a moving target rather than a settled product. Version strings carry full timestamps down to the second, which is a build identifier, not a semantic version. If you need to pin a dependency and reason about upgrades, that naming scheme gives you nothing to reason with. You get a date and a commit moment.
The second limitation is the interface itself. A workspace built on real-time fractal navigation and physics-simulated graphs is a high-motion environment. The photosensitivity warning is the project telling you that plainly. For a documentation team, a compliance archive, or anyone who needs to hand a tool to colleagues without a briefing, this is a poor fit. The third limitation is narrower and more technical: the value of a graph-of-thought assistant depends on the graph being good. If your notes are a flat pile of unlinked files, the traversal has nothing to walk, and you would be paying the fractal navigation cost for a mind map that is really a list. Neurite rewards an archive that is already densely linked.
How It Differs From Obsidian and Logseq
The obvious comparison is Obsidian or Logseq, both of which also treat notes as nodes in a graph. The difference is what the graph is for. In those tools the graph view is an inspection surface: you look at it to see structure, then you go back to a document to work. In Neurite, per the README, the fractal topology is the workspace, and the rendering persists and regenerates as you move through it. The graph is where the work happens, not a picture of it.
A second difference is that Neurite puts AI agents in the same graph as your notes. In Obsidian you would add a plugin that calls a model and returns text into a file. Here, an AI node is a node alongside text, images, videos and code, and the README describes graph-based multi-agent conversation between several AI and the user. That is a genuinely different composition model, and it is also the part with the least documentation in the material I have. If your actual need is a linked plain-text archive with a local model bolted on, the mature option is the safer choice. If your need is a spatial, agent-populated canvas, the alternatives do not offer it.
Licence, Maintenance and Upgrade Cost
Neurite is MIT licensed, which is permissive and places few obligations on how you use or redistribute it. This is not legal advice, and the licence file in the repository is the authority, not this paragraph. The practical implication of MIT here is that you can embed the code in your own tooling without a copyleft requirement, which is unusual for a project with this much UI surface.
Maintenance cost is the real question. The last push recorded is March 2026 and the most recent release is the June 2025 desktop build, so the project is not dormant, but the release artifacts are spread across three separately versioned components (desktop, frontend, servers) that can drift apart. Upgrading means tracking which combination is compatible, and the timestamp versioning gives you no compatibility signal. Budget for reading release notes and testing the desktop build against the server build rather than assuming a straightforward update path. The README's own framing, an open-source project in active development, is the accurate expectation to set.
Editorial conclusion
Adopt Neurite if you already think in graphs and want a local, MIT-licensed workspace where notes, links and agent nodes share one canvas, and you are comfortable reading the repository to fill gaps the README leaves. Do not adopt it if you need a stable, documented note-taking tool for a team, or if you cannot tolerate a UI that the project itself warns contains flashing lights. Before installing, verify three things: which release artifact matches your platform, whether the FractalGPT path depends on a local Ollama instance, and whether the Zettelkasten sync writes into your existing archive or only into a directory Neurite manages.
Community notes