Screencast series providing insights into how I structured my Mind Map using Node-RED. Node-RED is a computing engine, hence this Mind Map implementation is also an executable flow. This has a number of benefits demonstrated in these screencasts.
I began developing this Mind Map three years ago as a blogging solution (which I still use for this blog) but has now evolved into a AI-supported Chaos Map with everything I do intermixed into one large Mind Map. My Mind Map maintains flow code, maintains code for the Mind Map, maintains photo albums, stores my thoughts and creates articles such as this one.
Life is better with Node-RED version 5 - I created these screencast series now because NRv5 introductions so many features that are particularly useful for my Mind Map. For example, popovers for the documentation, multiple sidebars and improved zoom capabilities make using my Mind Map so much simpler and, basically, nicer.
This solution is based on a bunch of nodes that I have are created. The flow that manages those nodes is shown in part 0 (5 mins 50 secs in). There are no modification to the core of Node-RED at all, modifications are made as part of the node package, e.g. drag & drop modifications.
I describe the architecture of this Mind Map setup at the bottom of this blog page. I try to keep the screencasts non-technical only demonstrating the features not the implementation.
Disclaimer:
The AI transcripts of each screencast is created by AI based off the transcription of the audio. How I do this is shown in part 4, where I talk about transcription, transcribing and reformatting using local AI models. The transcripts are more or less accurate. The headlines certainly seem to be very accurate. They aren’t a true transcript of what I say. But they cover the intentions of that I’m trying to say.
A short 12 minute fly-through of how and why I created this “Mind Map” (or perhaps Chaos-Map) solution for myself - consider this screencast to be the motivation for creating Mind Maps inside of Node-RED.
(12 mins, 59MB)
This is a pre-part one recording regarding mind maps designed for busy minds. In my screencast, I discuss what I consider to be “normal” or classical mind maps. These are the types where you begin with a central point—in this example, “travel”—and branch out into subtopics such as sightseeing, holidays, and planning. Each of those branches further subdivides into items like visit, discover, explore, taking photos, monuments, museums, and so on.
There are specific aspects of these classical mind maps that I find problematic. The primary issue is that information flows outward from a central point with no mechanism to return or cross-link. For instance, in a traditional structure, a “monument” cannot be directly linked to a “hostel” or “bed and breakfast.” If my chosen monument happens to be near my accommodation, or if it relates to the shower, the room, or the hotel in some way, I am unable to link those two concepts together within a classical framework.
This limitation is difficult for me to manage because my thoughts diverge in many directions, and I frequently discover unexpected relationships between disparate items. Furthermore, there is often no strict definition of what these hierarchical relationships signify. In the example provided, the map suggests that travel is related to sightseeing, holidays, planes, accommodation, planning, and transport. While these are components of travel, my perspective differs. Sightseeing is also part of living or experiencing holidays, which may not necessarily involve travel or flying. A holiday can simply be relaxing on the sofa. Because my thinking involves complex interrelationships rather than strict hierarchies, I cannot treat these topics as isolated entities. This is precisely why I developed this specific mind map approach for busy minds.
In my screencast, I utilise simple examples and do not fully explore the appearance of the map once it becomes complicated. However, I did briefly show an example: my Aeon Mind Map. This section contains numerous articles I have read from Aeon Magazine. All these articles relate to the central “Aeon” topic. Links extend downward to additional articles, along with my comments and quotes extracted from them.
Crucially, these notes are interrelated to other activities I engage in much later. For example, certain images relate to a workshop I attended this year, while the connected article was read several years ago. This illustrates that links are often created long after the initial content is added. Over time, this affects the entire structure of the mind map, causing it to appear chaotic. While this may seem disorganised, it is acceptable and functional for my workflow.
The very first mind map I started with includes aspects of myself, such as my artwork and creative projects from years past. It also contains topics regarding AI, including my thoughts and articles on the subject, as well as societal issues I contemplate and reflections on mortality.
To demonstrate how these connections function, I use a pathway tool. When searching for all pathways from “societal” to other nodes, the tool reveals 42,000 unique pathways connecting topics like Idiocracy, mundane life, and Brave New World. If I perform a random selection, the system might trace a connection from “societal” to a dream I once had about a fridge. This path spans 42 steps—or nodes—tracing through various connections including death, the conscious world, and Aeon articles. Generating markdown from this pathway provides a textual representation of these complex mental journeys.
This mind map also houses specific organisational elements, such as an author timeline list featuring my favourite authors. It includes sounds I have created this year and represents the actual nodes of the mind map as a flow. For instance, the Scratch Pad package, which I maintain, is represented here. While the code resides on GitHub, the repository itself is maintained via Node-RED flows within the mind map. These flows handle functionality for committing to GitHub, publishing to npm, and updating flows on flows.nodered.org.
This centralisation places my technical work alongside every other aspect of my life. The Scratch Pad package is inspired by the scratch buffer in Emacs, originally coded by Richard Stallman. If I had a node referencing Richard Stallman, I would likely link this package to him as well. This highlights how personal interests and professional tasks coexist.
The map also includes personal memories, such as holiday photos from Australia, including an image of feeding seagulls at the beach—something I enjoy doing. I do not see a conflict in mixing coding, art, life events, and technical maintenance. This integration is the primary aim of these mind map nodes.
The appearance of this mind map may seem strange compared to classical, highly organised structures. However, I prefer this chaotic arrangement because the tool supports my natural thinking process rather than dictating how I should think. This distinction is a vital aim of the project. While the map remains chaotic, I employ tools to navigate it effectively:
These features help me organise my view without forcing rigid structure. The main goal is to get thoughts out of my head quickly and move on. When writing articles, I may create more organised mini-structures, but generally, the priority is capturing ideas before they are lost.
Visually, I utilise the built-in Node-RED visualisation for nodes. This approach offers a personalised representation of ideas. Many mind map tools require users to make stylistic decisions, such as whether connections should flow left-to-right or top-to-bottom. I prefer not to make these decisions, as they distract from the core objective: building a tool that allows me to think and organise my thoughts in a chaotic yet creative manner.
The visual layout is determined by how Node-RED works; images appear at the bottom of nodes because that is how the system handles them. This is not intended as a prescription for how everyone should build mind maps. It is simply the method that works for me, allowing my specific mental processes to flourish without the constraints of traditional formatting.
Can nodes represent thoughts is the core question that I address in this screencast. What are some of the consequences if Mind Maps become executable flows. Twenty minutes covering creation and exploration of Mind Maps in Node-RED.
(21 mins, 51MB)
This series of screencasts explores mind maps for busy minds. I have been developing this mind map tooling within Node-RED for approximately three years. With the release of Node-RED 5, several advantages make creating a mind map in Node-RED even more effective.
What do I mean by “mind maps for busy minds”? To understand this, it helps to compare my approach to the classical mind map. A traditional mind map typically features a central node with satellite nodes connected outwardly, following a strict sequence of ideas radiating from the centre. In that model, connections across non-adjacent branches are generally not allowed.
My approach differs significantly. My mental process involves interconnecting thoughts freely, regardless of hierarchy or direction. Connections develop over time—sometimes over years—and spread across multiple flow tabs. This results in a highly interactive mind map that is dynamic rather than static.
Content enters the map using the standard Node-RED editor. Each node utilises standard attributes:
In Node-RED 5, nodes display a badge indicating available documentation. My mind map nodes leverage these same attributes, ensuring they are fully integrated into Node-RED. Because they are standard nodes, they are also executable.
The executability of the mind map offers significant advantages. To demonstrate this, consider an inject node that triggers a message through the flow. As the message travels through the interconnected “circus of thoughts,” it may encounter loops.
The system includes loop detection. If a node detects a loop, it stops the message from continuing indefinitely, preventing infinite loops. Once a path hits a loop or an endpoint, the transmission ceases. This ensures stability while allowing complex interconnections.
One of the most powerful features is the ability to trace pathways. Over years of development, connections between nodes may seem strange or obscure. It is important to note that connections do not have predefined semantic meaning. I connect nodes because I perceive a relationship at that moment, but the nature of that relationship is flexible.
To analyse how thoughts evolve, I built a documentation generation sidebar. By highlighting a specific node, the tool can find all pathways leading to or from it. A “pathway” is defined as a route ending at an exit node—a node with no outward connections.
The tool fully supports standard Node-RED nodes alongside mind map-specific nodes. This allows for mixing code into the mind map. For instance, if a pathway leads to a Function node (which acts as an exit node due to having no outward connections), the tool identifies and highlights that entire path. This integration means the solution does not exist outside of Node-RED; it utilises existing features without altering core behaviour.
Each pathway represents a linear thought process. Since each node contains text (titles and content), these pathways can be converted into documents. I originally developed this tool to help write articles and blog posts using Node-RED.
The process works as follows:
This allows for the creation of structured articles where each section corresponds to a segment of the mental map. Comments can also be attached to individual nodes, providing context that may not appear in the final article but remains part of the thinking process.
The pathway tool respects loops. It recognises circular connections and does not treat them as valid linear pathways for document generation. While Node-RED’s native highlighting feature shows all links between selected nodes, this can sometimes be confusing if the actual taken path differs from the visual highlight. However, by clicking through the sidebar interface, users can follow the exact logical pathway without ambiguity.
A key utility is the ability to import a pathway as a Node-RED flow. This is particularly useful when working with linked nodes across multiple flow tabs.
This functionality applies to both mind map nodes and standard Node-RED code. For example, analysing the backend logic of the mind map itself (which handles drag-and-drop, content delivery, and local AI processing via Ollama) reveals complex pathways. Using the tool, I can:
Beyond Markdown, the tool can generate PDFs using Pandoc. By converting the extracted pathway into Markdown first, it is then automatically transformed into a downloadable PDF document. This provides a tangible record of specific thought processes or code logic.
This overview covers the basics of how the mind map works and how pathways are identified and utilised. The next instalment will detail how content is included in the mind map and how data from various sources is integrated into this executable environment.
Without content a Mind Map is as empty as a dried out well. This screencast explains how content can be dragged into the Mind Map. All content is stored locally and nodes contain references to that content.
(8 mins, 29MB)
Each node in my mind map—representing a specific thought or concept—can contain both a title and associated content. I can utilise the inbuilt editor to add this content directly. With the introduction of popovers in Node-RED 5, I can view this content within the popover interface or in the info bar. This functionality is particularly effective for text-based information. However, it is important to note that the native Node-RED editor is not specifically designed for extensive text entry; for instance, it lacks features such as a spell checker.
To address these limitations and enhance content ingestion, I have leveraged and extended existing Node-RED drag-and-drop functionalities. While Node-RED supports a baseline level of drag-and-drop, these enhancements are implemented specifically within the mind map node package rather than modifying the editor itself.
One significant extension involves integrating search results directly into the mind map. When performing searches, I can drag a specific result into the canvas as a “linked-out” node. The system automatically generates a corresponding “linked-in” node, facilitating the interconnection of content within the map.
Another extension allows for the transfer of content from mobile devices to my laptop, which can then be dragged into the mind map. As a Mac user, I utilise AirDrop to send content, such as images, from my mobile device to my MacBook. Once transferred, the image can be dragged directly into the mind map.
In cases involving specific formats like Apple’s HEIC (High Efficiency Image Container), the system handles necessary conversions. Because web browsers do not natively support displaying HEIC files, the mind map automatically converts the file to PNG format for display. This ensures that content requiring conversion is rendered correctly. This capability is part of the content management flow demonstrated in previous discussions.
The interface provides options to access the original file. By clicking the relevant button and opening a new tab, the original HEIC file can be downloaded, while the displayed version remains a PNG reference. Furthermore, if the source image contains metadata such as location data (common in mobile photography), this information is preserved and associated with the node. This feature enables the mind map to function effectively as a photo album, allowing users to view geotagged photos from activities like geocaching without needing to click through individual images repeatedly.
When dragging an image link from a web source, such as my blog, into the mind map, the system recognises the link and downloads the image for local storage. This process ensures that all content is stored locally on the drive, while the Node-RED flow references these files. The flow.json file does not store the actual data but rather maintains links to the external content.
This separation of data and configuration offers significant portability benefits. Because the mind map relies on standard flow.json structures without a proprietary data format, the entire generator flow can be imported into any other Node-RED instance seamlessly.
Beyond images, the system supports importing highlighted text. For example, if I highlight text from an article, I can create a standard text node or designate it specifically as a quote. If identified as a quote, the system generates a dedicated quote node with appropriate iconography.
I can also import the source URL as a bookmark node, which features a distinct bookmark logo. By connecting the quote node to the bookmark node, I establish a clear interrelationship between the extracted content and its original source. This method allows for structured organisation of information, linking derived insights directly to their origins.
The mind map also supports pathway analysis and documentation generation. Using the “Find Pathways” feature in Pathfinder, I can identify connections between nodes. Even if only a single pathway is identified, the system can generate Markdown output based on that structure.
This generated Markdown includes references to multimedia elements, such as images, ensuring that visual content is integrated into the document alongside textual data. By copying this Markdown and pasting it into a text node, I can view a complete, formatted document that combines text and image references effectively. This workflow demonstrates how interconnected nodes can be synthesised into cohesive, standalone documents.
This and the next two screencasts describe how I use a local AI models to do useful things inside my Mind Map. I place emphasises on being local-first: everything I do in my Mind Map should be usable without having an internet connection. Running local AI models does require sufficient computing however everything is backgrounded and I am never forced to wait for AI to complete: my Mind Map is blocked by AI jobs. AI Jobs are also queued so that my GPU/CPU aren’t overloaded.
(4 mins, 9MB)
The following section focuses on artificial intelligence integration within the mind map workflow. This process utilises a specific sidebar interface that houses the core functionality of the application. Among the various features available, the record button stands out as a primary tool. When activated, this button captures speech in real-time; the resulting recording becomes an integral part of the mind map once the session concludes.
After recording, the next step involves transcribing the audio content. This represents the first major application of AI within the workflow, utilising Whisper to convert audio into text. The transcription process operates asynchronously, meaning it runs in the background without interrupting other tasks. For instance, while one transcription is processing, a user can initiate another variation—such as a “karaoke” version—or manage other elements like clearing unwanted content from the trash can. Once the background task completes, a notification confirms that the transcription is finished.
The system demonstrates significant flexibility regarding audio sources. The transcribe function is not dependent on direct speech input into the mind map application. Instead, users can retrieve audio from external sources, such as video files. By selecting the appropriate button to extract audio from a video, the system allows for subsequent transcription of that extracted audio. This confirms that any audio snippet can be processed and converted to text, regardless of its origin.
In addition to transcription, the interface offers text-to-speech functionality located at the top of the sidebar. Users can convert existing text back into audio formats. The system supports various voice options, including different gendered voices (e.g., male and female). This feature allows for diverse auditory representations of the mind map content.
It is important to distinguish between the specific AI technologies used. While the Whisper transcription clearly employs AI, the text-to-audio conversion uses Piper TTS, which may or may not rely on AI-driven models depending on its underlying architecture. Furthermore, the workflow includes AI tasks powered by Ollama. A key advantage of this setup is that all these processes run locally, ensuring data privacy and reduced reliance on external cloud services for both transcription and task management.
The original aim of creating blog content hasn’t been lost and this screencast describes my workflow for creating content. My workflow consists of three steps: speaking, transcribing and formatting. As some programmers no longer write lines of code, I no longer write lines of blog posts, I speak them.
(13 mins, 41MB)
When creating texts or blog posts, I follow a specific workflow. For example, the current flow for this blog post asks, “Can code bases be broken?” I have approached this particular post slightly differently because I am experimenting with the process. The first step involves recording audio directly into my mind map. The initial audio clip asked, “Is your software broken? There can be no peace without war.” This represents the motivation phase of the content. It lasted approximately seven and a half to eight minutes.
Once the first audio segment is created, I queue it for transcription. While that transcription is processing, I record a second audio segment. This second part addresses the question, “Why is it important to recognise software as being broken?” This serves as the “why” component, following the initial motivation. A third section discusses possible solutions, and the remainder consists of general discussion. This second recording lasted about six minutes.
By the time I finish speaking the second part, the transcription of the first part is usually complete. Once the transcription finishes, I proceed to formatting. Transcribed text often appears as one long sentence without proper punctuation, such as full stops or commas. For instance, a recent transcription provided by Whisper lacked any structural breaks. This is where AI becomes useful. I use an AI tool, specifically a “Transcript Cleaner,” to reformat the text. I simply instruct it to reformat, and it processes the text in the background.
While the AI reformats the first section, I record subsequent parts. The third part discusses the concept of a “broken software badge.” This is akin to having a badge indicating whether tests are succeeding or failing; here, the badge indicates whether the software is broken, which requires a metric for brokenness. The fourth part covers this metric, defining how something can be considered broken.
These AI tasks run in the background while I continue speaking and recording new segments. By the time I reach the final segment, I only need to transcribe and format that specific portion. I do not need to watch the process complete; I can proceed with other tasks. This demonstrates how the mind map supports a busy mind. Once a task is queued, the tool does not freeze, nor do I have to stare at a prompt waiting for an answer.
Running everything locally takes longer than using a software-as-a-service (SaaS) solution, which would be significantly faster but also much more expensive. The trade-off here is time versus money. However, this local approach does not prevent me from multitasking. I am not stopped from doing other things while the AI processes in the background.
For this specific article, I posted a summary of the text rather than the full transcript. The six components were transcribed and then reformatted. The reformatted version includes headlines added by the AI, preserving the original spoken text while improving structure. When reviewing the word count, the original article would have been approximately 3,000 to 4,000 words.
Instead of publishing the full length, I used an AI summary task. These tasks are defined in my AI flow via specific nodes, each associated with a different prompt. The summary reduced the content to approximately 530 words. This was a favour to the audience, condensing 4,000 words into a concise 500-word overview. People do not need to read or listen to thousands of words when a summary captures the core message effectively.
The topic of broken software is philosophical and difficult to convey on a meta-level. Most people do not have time to consider whether code bases can truly be “broken” in depth. The summary encapsulates everything I wanted to say about this complex issue.
While working, other formatting tasks completed in the background. I utilise two different formatting approaches:
Both tools likely use the same underlying model (e.g., Qwen 3.6 locally) but apply different prompts and system prompts to achieve distinct results. Additionally, there is an image generation capability within the flow.
I can instruct the AI to create an image based on a summary or a specific description, such as a sunset. This task runs asynchronously in the background, allowing me to continue working. For example, while waiting for the image generation, I managed content within my mind map.
Deleting nodes in the mind map removes references but not necessarily the underlying file content on the hard drive. To address this, I have a “trash can flow” that ensures when I delete a node with content, the actual file is removed from the hard drive as well. This keeps the digital workspace clean.
Other integrations include copying content to a CDN automatically when publishing articles, eliminating the need for manual copy-and-paste operations. There is also a Hacker News tree import feature, which is relevant for importing data from platforms like Reddit as well.
I demonstrated the image generation results, including an AI interpretation of the summary text and a generated sunset image. These images were moved to the trash can to clear the workspace. The next episode will cover the Hacker News tree import and AI classification features, particularly how content such as quotes can be automatically classified via drag-and-drop without manual intervention.
Visually classifying content to make it more understandable.
(9 mins, 30MB)
To complete the AI integration within my mind map, I will discuss AI classification and its specific functions. Having established the content base, I can now classify that material. I will demonstrate this using transcriptions, taking the original spoken content and placing it into the workflow. These represent the original texts that were transcribed. By highlighting all of them and selecting “classify,” the system takes each text block and categorises it according to keywords.
Each piece of text possesses one or several focal points. The AI attempts to retrieve these focuses—typically one or two keywords—and attaches them to the article. Because keywords can overlap, transcribing a single article generates a set of keywords. When processing subsequent content, the system checks for existing keywords and connects the new text with those established tags. This process creates an interconnected tree illustrating how different contents relate to one another.
Although these examples are highly related because they originate from the same article about working software, this method also applies to random internet content. By classifying diverse inputs, the system generates keyword trees that reveal structural relationships. Additionally, I can utilise the auto-align feature to organise these elements visually.
Upon initial classification, the system identifies keywords, including summarisations that may not be necessary for this specific view. The second piece of content is then processed, looking for existing keywords to establish connections. In this instance, topics such as software quality in industry overlap with the current article, while introducing new terminology.
As a third item is added, the visualisation can become chaotic. The new keywords interrelate precisely with those from the previous two items. For example, there is an overlap with the second article regarding bugs, discipline, and updates. Simultaneously, it connects with the first article through concepts like industry, broken cycles, and software. Interestingly, while quality is shared between certain contents, other themes diverge. By moving these elements and applying an auto-layout, a clearer picture emerges: a network involving continually updating cycles, fixing brokenness, software acceptance, users, society releases, and maintenance.
When introducing a fourth item, the complexity increases significantly. This new content interrelates with the third item via releases and with the second via developers (or updates). The visualisation becomes increasingly confusing as these nodes multiply. Adding a fifth item reveals that it is strangely unrelated to the fourth but connects elsewhere in the tree.
To manage this complexity, I can filter out noise by selecting unlinked keywords and unlinked quotes. There are two distinct types of unlinked items: quotes (which represent important ideas) and keywords. By highlighting and deleting these unlinked elements, the visualisation cleans up to reveal the core concepts interrelated across all texts.
After removing the noise, the remaining core keywords provide insight into both my original intent and the AI’s interpretation of the content. The shared keywords include:
Notice that no quotes are shared; only keywords connect these disparate pieces. This demonstrates another powerful usage of AI: creating structural trees that map conceptual relationships. I can further refine this by testing different layout algorithms, such as box layout or tree layout. In this case, the tree layout remains the most effective visual representation. This functionality is supported by a separate node package for auto-layout, proving its utility in organising complex informational networks within Node-Red.
This and the next screencast present experimental gimmicks that I have implemented because I find them useful. I talk about importing Hacker News comment threads as trees and then using audification to listen to comments. I don’t do this everyday :)
(9 mins, 40MB)
This demonstration illustrates a tree-like structure generated by artificial intelligence based on specific keywords. To provide a concrete example, we can look at Hacker News, which inherently functions as a hierarchical, tree-like data structure.
I have integrated a Hacker News import feature because I am an avid user of the platform. Let us examine the Hacker News front page. If I select a specific link—such as an article about AI-generated videos that currently has 81 comments—the system does not merely bookmark the link. Instead, it captures the entire discussion thread.
In this view, you can see the link to the original article: “AI-generated viewers to maximise drive target brain region.” Below the headline lies the tree-like structure itself. This consists of comments nested within other comments, creating multiple layers of conversation.
While Hacker News typically places highly voted content at the top, this does not necessarily mean it is the most relevant or interesting material for every individual reader. The discussion can extend significantly downward—in some cases involving hundreds of comments—making it difficult to locate specific insights manually. For the sake of this demonstration, I imported a thread with approximately 80 comments to keep the dataset manageable.
Although raw comment threads can be overwhelming, applying an auto-layout algorithm transforms the data into a clear tree structure. In this specific instance, the system formatted 82 nodes (representing the original post plus 81 comments). This visualisation allows us to identify interesting comment lines and trace their position within the hierarchy.
One notable comment in this thread reads: “Not sure you’re funny about it, ancient word.” While the text is somewhat ambiguous, it demonstrates how the tool represents nested conversations. Although I created this specific import for Hacker News, the same logic applies to other platforms like Reddit or any site featuring nested comments. You can generate these tree-like structures for virtually any hierarchical discussion forum.
Because this structure is fully integrated into the mind map environment, advanced features become accessible. For instance, I can convert the textual comments into audio. By highlighting the relevant notes and selecting text-to-speech, the system generates speech files in the background. These are added to the workflow while I continue working on other tasks.
Additionally, I can utilise the Pathfinder tool to identify all pathways through the data. By sorting for the longest pathways, I can isolate the primary discussion threads I wish to analyse. Once identified, I can generate a Markdown document representing that specific thread as a single, coherent document.
When clicking on a specific node in the mind map, the interface scrolls directly to the corresponding content in the flow, highlighting the comment for easy reference. This capability effectively converts scattered online discussions into structured documents.
Let us examine one of these converted threads. The content begins with a premise regarding AI-generated videos and their potential impact on humanity:
“We’re getting to the point where tech industry must be stopped if humanity is to continue at all, let alone thrive.”
The tone appears pessimistic. On this particular website, every technological advancement is framed as progress. However, one might ask: progress towards what?
The commentary suggests that progress often serves advertisement efficiencies. The argument posits that advertising effectively runs the world. Imagining a world without ads implies an economic halt. Conversely, exploitation and manipulation enable the creation of large capital reserves, which have historically funded monumental achievements such as pyramids, temples, space exploration, and scientific research. Even current advances in AI and Large Language Models (LLMs) are made possible by this mass exploitation. Without these mechanisms, such developments would not be feasible. The author notes uncertainty regarding whether the preceding statements were satirical or serious.
Another perspective in the thread highlights the dark side of capital accumulation:
“Those ancient wonders were enabled by slave labor; treating people as capital is the ultimate climax of capitalism.”
The discussion continues with a critique of social media platforms:
“This is the absolutely horrific next stage for social media platforms. They’re already well able to surface the most addictive short video for a specific user out of millions of real videos. But these millions of real videos are just ads thrown into the space of videos that could hook the user. In the end, even the best selected of them is not perfect.”
The thread concludes with a warning about AI’s potential to exploit human psychology:
“Now, behold. AI allows generating the perfect video to surgically hit all the switches in the viewer’s brain and turn it into a zombie hooked for days on end. Let’s hope our regulations hit these social networks hard enough so that they never dare deploy this kind of technology.”
Beyond visualisation, I can demonstrate additional functionality by importing this specific discussion thread as a single flow. Once imported, I can generate text-to-speech for the entire structure and replace the source text nodes with audio files.
Initially, the interface may not update immediately; reloading the flow or clicking on the nodes reveals the change. The original text nodes are transformed into audio nodes. After saving and reloading the browser, the nodes are confirmed as audio files. I can then play the audio directly within the mind map.
When transcribing text to audio, the system retains the original text alongside the audio file, providing a transcript button for reference. If switching browser tabs, the audio playback stops automatically.
This workflow demonstrates how to audio-file content from the internet and display complex, tree-like structures within a mind map environment, transforming flat web discussions into interactive, multi-media knowledge graphs.
A philosophical screencast discussing one dimensional web pages, two dimensional flow coding and three dimensional Mind Maps. Why aren’t we, as programmers, using 3D programming tools? Because it is too expensive, too difficult or we lack the imagination to imagine a better future.
(10 mins, 34MB)
When I first started using Node-RED, one aspect I deeply appreciated was the two-dimensionality of the interface. Navigating up, down, left, and right provides a spatial awareness that is distinct from traditional programming environments. Many programmers are accustomed to a strictly linear, top-to-bottom workflow—a one-dimensional perspective. In contrast, I find Node-RED’s additional dimension highly beneficial.
To illustrate this difference, consider how I navigate my mind map. In a one-dimensional view, I can locate specific nodes, such as the “John Cage” node. Once found, I can trace its connections to see immediate ancestors and parents. For instance, moving to the “433 Piece of Silence” reveals the structural relationships within that single linear path. This view also supports multimedia integration, allowing for rich content within a simple structure.
However, relying solely on this one-dimensional perspective has limitations. While it helps focus attention on a single element—such as exploring “14 Variations” or specific time durations like “40 minutes”—it lacks context. Without an overarching map, it is difficult to perceive that you are navigating within a multi-dimensional mind map. The overview at the bottom reveals the complexity and ease of navigation that two dimensions provide. This spatial layout allows for intuitive movement through information, which is far richer than text-based linear coding.
If a two-dimensional world offers richness through images, flows, and sounds, what does a three-dimensional world offer? This is where my exploration into 3D representations begins. Using a Meta Quest headset, I have created a three-dimensional visualisation of my mind map. While this does not render in standard browsers, the video demonstration shows how nodes appear as spheres connected by red lines.
This process is not merely a preview; it involves generating the mind map dynamically. Each sphere represents a node, and the red lines indicate connections. As the system generates these elements, sounds accompany the appearance and disappearance of thoughts—simulating ideas knocking together or fading away. Visually, this resembles a galaxy, where each thought acts as its own light source or sun, creating a universe of thoughts.
This experiment aims to visually represent how I imagine my thoughts are organised internally. Because current hardware limitations (whether related to Meta Quest capabilities or Babylon.js rendering constraints) prevent displaying the entire map at once, this serves as an exploratory tool. It allows me to see how thoughts might be structured in three-dimensional space, providing a visual representation of cognitive organisation.
In an earlier version of this project, which I no longer maintain, I implemented a mechanic where thoughts could be discarded. Users could generate thoughts and then “throw them away.” These discarded ideas would float upward toward the top of the screen and disappear, or roll along a virtual plane until they fell off the edge.
This mechanism was psychologically significant. It helped me conceptualise thoughts as transient objects that can roll away and disappear. Accepting that certain thoughts are gone—and that the mental space returns to an empty state—is a healthy cognitive practice. This three-dimensional representation aids in understanding how a busy mind works. It reinforces the idea that it is acceptable to let go of non-essential thoughts, knowing that truly important ideas will return.
This leads to a broader argument about programming and thought organisation. Just as we should move beyond linear code to two-dimensional flows like Node-RED, we should also embrace three-dimensional programming. Creating programs using three-dimensional technology represents a significant step forward for developers.
The form chosen to represent thoughts actively influences those thoughts. This is a process of self-reflection and self-interaction. For example:
This visual organisation feeds back into how we structure our thinking. By placing thoughts in specific locations within a 2D or 3D space, we create new inspirations and connections. Therefore, the next logical step is to fully develop this three-dimensional approach, enabling us to think about where thoughts are placed in three-dimensional space, further enriching our cognitive frameworks.
What do I need to support this Mind Map? I use an extra Node-RED to provide the interface to Ollama, Whisper.cpp and PiperTTS - these run in docker containers locally. Each service has a single dedicated flow that I maintain using FlowHub.org. These flows implementing queuing of jobs to ensure that GPU/CPU resources aren’t overloaded by requests.
There is a collection of Mind Map nodes (shown in Part 0) that I maintain in a separate Node-RED instance. I can code and test those nodes in that instance, before updating the nodes that run my Mind Map.
The Mind Map is running in a further instance of Node-RED which also includes a “content management” flow that handles local downloading, interfacing to the AI functionality and supporting drag & drop functionality.
In total, at least six separate flows make up my Mind Map solution. Each flow is maintained as any other flow, just as my Mind Map is a flow. Everything is extended and built inside of Node-RED, for nodes I use the NodeDev package.