I Built Storm: A Visual AI Workspace & Brainstorming Canvas in Python

ghua8088 — Sun, 05 Jul 2026 08:07:31 +0000

As AI tools have evolved, I found myself constantly jumping between ChatGPT for brainstorming, a code editor for prototyping, and Obsidian for note-taking. The context switching was killing my productivity.

I wanted an AI assistant that didn't just spit text into a chatbox, but actually worked alongside me in a unified canvas.

So I built Storm—a premium, visual AI brainstorming canvas built natively in Python using the Pytron framework.

What is Storm?

Storm is an Obsidian-like markdown workspace supercharged with a LangGraph/LangChain agent backend. It provides a split-screen canvas where the AI can brainstorm with you in chat, and simultaneously output structured, rendered notes into a living document.

Here are the features that make it a powerhouse for productivity:

1. Interactive Markdown Canvas

Storm doesn't just generate static markdown. The AI generates interactive elements.

If the AI generates a checklist, clicking a checkbox in the preview automatically updates the underlying .md file in real time.
If the AI generates HTML buttons, those buttons can dynamically trigger Python functions on the backend.

2. Consolidated AI Brainstorming Notes

Instead of scrolling up endlessly through a chat history to find a good idea, Storm consolidates blueprints, code snippets, and structured thoughts directly into a neat brainstorm/ catalog in your workspace. You can toggle between the rendered preview and the raw Markdown source code instantly.

3. Secure Terminal Execution

One of the scariest parts of giving AI access to your computer is terminal execution. Storm solves this with a Secure Terminal Sandbox. When the AI wants to run a shell command, the Pytron bridge triggers a native GUI confirmation dialog on your screen, allowing you to explicitly confirm or deny the execution request.

4. Multimodal Drag-and-Drop

Storm natively supports visual models (GPT-4o, Gemini 1.5 Pro). You can seamlessly drag and drop UI mockups, architecture diagrams, or screenshots directly into the chat, and the AI will analyze them and update your canvas notes accordingly.

5. Persistent Personality Memory

Storm features a user.md memory store in the root of your workspace. It acts as a long-term profile memory, automatically injecting your custom preferences into the agent's instructions so it never forgets your coding style or project architecture.

The Tech Stack (Zero Electron Bloat)

I built Storm using Pytron, which allowed me to bypass the massive overhead of Electron.

Backend: Python (LangChain, LangGraph) for robust AI orchestration and seamless OS integrations.
Frontend: React (Vite) for a fast, glassmorphic UI.
Models: Built-in settings dashboard to hot-swap between OpenAI, Google Gemini, or local .gguf models running entirely offline via LlamaCpp.

Try it out!

I'd love to hear what you guys think. What is your current workflow for AI brainstorming, and how could an integrated canvas make it better?

Check out the source code, run it locally, and start building!

🔗 GitHub Repository: https://github.com/Ghua8088/Agent-Playground

I built a POC for an IDE that visually maps and edits architecture using Local AI

ghua8088 — Mon, 29 Jun 2026 19:49:07 +0000

Most "AI IDEs" today are essentially just VS Code forks with a chat UI bolted on. You paste some code into a sidebar, get some code out, and manually copy it over.

While this is incredibly useful, it still forces developers to explain architectural changes through flat text and deal with context window exhaustion.

I wanted to experiment with a radically different approach: What if the IDE understood your architecture visually?

So, I built a Proof of Concept (POC) called TerminateCode.

The Core Concept: Visual Architecture

TerminateCode represents your code as an interactive node graph on a canvas, alongside your standard text editor.

The vision is simple: Instead of typing "refactor the auth module to a new layer," you manipulate the architecture visually by dragging nodes on the canvas, and the AI writes the underlying implementation to match your new structure. It bridges the gap between high-level system design and low-level code implementation.

Solving the Context Problem: Local RAG

One of the biggest issues with AI coding is that models quickly forget what you told them 10 prompts ago.

To solve this, TerminateCode maintains a local vector database per project. This creates a semantic "memory" of your codebase. When the AI needs to recall how a specific function is implemented, it queries the local DB rather than forcing you to paste thousands of lines of context into a prompt.

It takes up some disk space, but it saves an enormous amount of tokens and prevents the AI from hallucinating missing context.

Extreme Privacy: Local GGUF Models

Enterprise developers often can't send proprietary code to external APIs.

TerminateCode integrates directly with the HuggingFace GGUF Hub. You can search for, download, and run powerful models (like Qwen or Llama) entirely locally within the IDE.

This means 100% zero telemetry and total intellectual property protection. The AI runs on your hardware.

How it was built (The Tech Stack)

Because I wanted to prototype this quickly but keep it fully native, I built TerminateCode on top of Pytron (a framework for building desktop apps with Python and web technologies).

Backend (Python): Handles the local RAG database, the LLM execution (via local models), and the heavy system integrations.
Frontend (React): Houses the Monaco Editor for the coding experience, and React Flow for the visual node graphs.

Pytron bridges the two seamlessly using OS-native webviews, so it runs much lighter than a standard Electron application.

It's just a POC (For now)

I want to be completely transparent: This is a highly experimental Proof of Concept.

It is rough around the edges, and there are plenty of bugs to squash. However, the core foundation—the local DB, the GGUF downloader, the Monaco integration, and the node canvas—is functional.

I am sharing this because I want to see if other developers believe that this "visual architecture" approach is the future of AI-assisted programming.

If you see the vision and want to tinker with the code, or just want to try running local models in an IDE, check out the repository:

GitHub - TerminateCode

I'd love to hear your feedback in the comments! Is visual node manipulation the next step for AI coding?

DEV Community: ghua8088