NodeBox Repo + DeepWiki (Can other AI tools do this?)

I've indexed the NodeBox GitHub repo on several platforms just out of curiosity, but also, to help the community continue the discussion around NodeBox and AI (what is useful/what is not)...

1. DeepWiki
   I gave it a prompt asking exactly how to setup and connect nodes to create Guilloche designs with custom/adjustable parameters.

This was its first response:

Found a highly relevant example — a Spirograph node setup already exists in the codebase. Let me examine it directly, along with the corevector node library for relevant node definitions.

What I could confirm

NodeBox's vector geometry nodes live in the corevector library 1 , and the transform-and-duplicate logic your Yin-Yang example uses (Ellipse → Copy → Colorize → Combine) is exactly the same mechanism the codebase itself uses to build a Spirograph pattern — which is structurally the same technique as a Guilloché generator (repeated rotated/translated/scaled copies of a base curve superimposed to create the moiré-like interference pattern).

This is confirmed by a performance test that explicitly drives a copy1.rotate port on a bundled example to animate "a full spirograph": 2

That example file lives at examples/01 Basics/01 Shape/11 Spirograph/11 Spirograph.ndbx in the repo, but I was unable to retrieve its actual node graph contents through the index (see note at the end).

I was also able to confirm the exact port structure of the corevector.copy node — the same node used in your Yin-Yang description — from the format-upgrade code and its regression test, which manipulate a copy node's scale port (a Point) alongside translate/rotate/order/copies: 3 4

This matches your description of Copy node's Order, Translate, Rotate, Scale inputs one-to-one — confirming Copy is the right, and only, primitive you need for repetition/rotation, rather than building trigonometric formulas node-by-node.

Separately, handle classes reveal other relevant corevector shape/transform nodes exist beyond what's in your example: line, star, polygon, and reflect all have dedicated UI handles, meaning they exist as first-class nodes: 5

The reusable-group mechanism you asked about (custom "Networks") is the groupIntoNetwork action, which take selected nodes and turns them into a sub-network, and publish/unpublish, which expose a child node's port as an input on the network itself so the group behaves like a parameterized custom node: 6 7

The rendering semantics of a network confirm that a group renders whichever child is marked as its "rendered child," and published ports feed values from outside the group into specific child ports: 8

Recommended structure (conceptually)

A Guilloché pattern is mathematically the superposition of two (or more) rotating/translating frequencies applied to a base curve (the same principle as a Spirograph/hypotrochoid or an engine-turning lathe). In NodeBox terms that maps to nesting two Copy nodes, each representing one rotational frequency, rather than computing trig formulas directly:

1. Base shape node (e.g. Line or Ellipse) — the "pen stroke" unit.
2. Copy node #1 ("inner wheel"): small Rotate angle, many Copies, small radial Translate — produces the first epicyclic ring.
3. Wrap step 2 (base shape + Copy #1) into a custom Network, publishing Rotate, Copies, Translate, and Scale as the network's own inputs — this becomes your reusable "Guilloché ring" building block, avoids re-deriving the same node chain per frequency, and matches how publish/groupIntoNetwork are meant to be used.
4. Instantiate that Network twice (or more) with different published parameter values (different rotation speed/radius per instance) to superimpose frequencies, feeding the result of instance 1 into the shape input of instance 2's inner Copy.
5. Colorize node(s) for stroke/fill styling of each layer.
6. Combine node to merge multiple layers/instances into one final output, exactly as in your Yin-Yang example.

What I could not verify

I was not able to pull the actual .ndbx XML contents of libraries/corevector/corevector.ndbx or the bundled 11 Spirograph.ndbx example — the search tool returned only match counts, not file bodies, likely due to index size limits on binary/XML asset files. That means I cannot give you exact default parameter values, port names for line/star/polygon/reflect, or the precise wiring used in the built-in Spirograph example (which would be the most authoritative concrete Guilloché template). I'd recommend starting a Devin session with filesystem access to open libraries/corevector/corevector.ndbx and examples/01 Basics/01 Shape/11 Spirograph/11 Spirograph.ndbx directly — that will give exact port names/defaults to replicate or extend, and confirm whether a dedicated "spiral" math node exists that could simplify the radial term instead of nesting Copy nodes."

I tried the same prompt again in a new session to clarify a more specific use case for the Guilloche designs.

This response was much more direct and it even generated a conceptual diagram of a basic node layout!
See the attached 'guilloche_deepwiki' image...

You can read the first prompt/response conversation here:
https://deepwiki.com/search/i-would-like-to-know-what-node_7dbb47c3-79dc-4e32-98ac-7a5efcd830b6?mode=deep

And the second where I used the same prompt with calrifications and got the response explaining how to do it and the diagram as well, here:
https://deepwiki.com/search/i-would-like-to-know-what-node_11e77fcc-16ae-4da7-90b5-1ab37bfbd11a

2. OpenDeepWiki
   This one automatically generated a SKILL file that can be used by an agent to be an expert in NodeBox source code development - and potentially, for those who have 'computer use' type agents, USE THE SOFTWARE directly!
   (This is the attached 'nodebox-nodebox-master-en-skill' ZIP file.)

3. RepoWise
   Provides a comprehensive analysis of exactly what parts of the source code itself will benefit, objectively, from refactoring. It then goes further by showing exactly which of those tasks are purely technical refactors that will not break any code and do not require any judgement or decision from a live developer to complete the fix - which it shows how to automate - and provides concise breakdowns of the remaining tasks that do need human judgement calls or those that are highest priority, or even least time consuming but also not as urgent.

And that is just the refactoring analysis... there are many more codebase insights and utilities.
I've attached a screenshot of the top of the refactor tab:
'repowise_refactor_tasks'

I tried to keep this short.
I highly suggest checking out the DeepWiki NodeBox page - this platform is 100% completely free to chat as much as needed and find out anything about how to use NodeBox or build new ideas out, as well as, development questions.
Straightforward with less features than the other platforms which geared towards developers and have the premium/paid features.

DEEPWIKI:
https://deepwiki.com/nodebox/nodebox
First conversation (where it explained how to go about using the Spirograph NodeBox example project approach to generate Guilloche designs...):
[https://deepwiki.com/search/i-would-like-to-know-what-node_7dbb47c3-79dc-4e32-98ac-7a5efcd830b6?mode=deep]
Second conversation (using same prompt with an extra paragraph at the end to clarify what I actually expected a bit more and ended up getting that along with a pretty nice diagram...):
[https://deepwiki.com/search/i-would-like-to-know-what-node_11e77fcc-16ae-4da7-90b5-1ab37bfbd11a]

OPENDEEPWIKI:
https://opendeep.wiki/nodebox/nodebox

REPOWISE:
https://repowise.dev/repo/nodebox/nodebox

Wow.

I'm not very current with the whole AI scene, so hadn't even heard of DeepWiki before. Thanks for doing this.

There is a lot to digest here. I've spent a little time fumbling my way through parts of the Nodebox GitHub repo without having much of a clue about the overall architecture. This resource would have saved me a lot of time.

You mentioned the spirograph example. It's actually easy to examine and retrieve all those example. Launch Nodebox then, under the File menu, go to Open Examples and navigate to the example you are interested in. A standard NodeBox file will open in a new window and you can play with it, change it, or save a copy.

I have attached the spirograph.ndbx file (zipped).

I have to go to bed now and it may be a while before I find the time to really explore this DeepWiki documentation. But if you, Edge, or anyone else finds interesting tidbits therein, please share your discoveries in this thread!

Well, I was aware of the example files... I have never learned enough about how all of the nodes work on their own or comprehensively to understand a lot of them. Or I was not able to connect how they were being used in one example with what they could have been used for in some idea of my own that I wanted to build.

But after another short conversation with the DeepWiki model, I see why it is that it referenced the Spirograph example in response to my first prompt. (I had honestly forgotten about the examples and that this was one of them - I just finally redownloaded NodeBox since my laptop recently died and I had not used it in a while at that.)

DeepWiki it seems is more for developers who need to know about the actual code for a project that they may not yet be familiar with so that they can more easily understand the 'standards' or 'approaches' a specific project uses or other technical things that I know nothing of...

When I have used DeepWiki in the past a couple times just trying to learn more about how to code, its default response 'framework' is exactly from the context of the specific codebase one is chatting with by default. So when I would ask how to go about coding a specific functionality that was not part of that project's own codebase, it always seemed to be unaware that I was asking about how to achieve that functionality by wanting DeepWiki to use the codebase to GENERATE NEW CODE with the intended functionality.

For example, in original Guilloche prompt I forgot that it would do this. So I did not think that by asking how to create the node layout, etc, for a 'proper' Guilloche design that it would only be answering based on the NodeBox repo, literally, as it has indexed it.

When it mentioned the Spirograph that is when I remembered that DeepWiki is great at generating responses based on its knowledge of the codebase - I never considered that the mathematical principles of a Guilloche design and Spirograph until it made it obvious.

But the Spirograph and the underlying math was not all of the functionality I was looking for and DeepWiki was only referencing exactly what I included in my prompt against the codebase (as a prompt in DeepWiki is technically an 'intelligent search' of the codebase itself) and then return its response.

One must always be explicit in a DeepWiki prompt and also include key details of what you need while making sure to clarify that some things may not be found in the code itself but fror it to use its understanding of the code to help you do what you are trying to do with it - even if that means DeepWiki has to generate ideas/suggestions from scratch based on how the code actually works - like how to actually build a node graph using the NodeBox UI and because DeepWiki can understand how the software works on a code level, if one clarifies this type of intention, it will explain it. Otherwise, it will just answer using the codebase itself as a search result that it thinks best matched what you were asking.

Thus, I had to point out the differences in the Guilloche design I was after and the Spirograph example that it would find in the codebase was similar but not what I was after.

Long-winded, I apologize.

Oh and I rarely deal with AI either... I just remembered learning about DeepWiki from an old article I read:

How I Built a Working n8n Workflow Using DeepWiki

And I figured since I was so rusty and was never really that good with NodeBox, I needed to find some decent tools to bring me up to speed with it since had the realization that it is probably a good fit for this project that I actually need to get done. And I have been considering extending the functionality of it when I realized that the JavaScript project I have built the code for actually needs a node graph builder UI to actually really make it useful in the way I want it to be... but I cannot see having to build code to do that on my own from scratch.

It would be much easier to extend NodeBox and just recreate the functionality of the JavaScript code or use it as is (because my JavaScript can pass any message and receive the response to and from any Python function directly in sub-millisecond time). :) :) :)

And I ain't gonna make it public just to ask DeepWiki how to build my UI for it quite yet!!! ;) ;) ;)

I have plans for it.

Plenty of AI helped me write each of the individual functions that went into that project. But none of them actually know what I was doing with all of them on my own.

Haha. I just cannot code - I have the rest figured out!