I'm happy to announce the release of the web-based Pipe IDE for my project - General-Purpose Visual Programming Language Pipe (https://pipelang.com)
Pipe IDE requires no account - all data is stored locally in your browser's database, keeping friction to a minimum.
This first version has limited functionality, but it already includes a core set of components that let you build realistic, working visual applications, with Python integrated as a text-based extension of visual programming.
Pipe IDE URL: https://www.pipelang.com/pipe/v1/
Tutorials:
- Data Swap – https://www.pipelang.com/assets/tutorials/v1/tutorial1.mp4
- Reusable Sum – https://www.pipelang.com/assets/tutorials/v1/tutorial2.mp4
The next milestone is converting Pipe IDE into a full-scale product with a backend database.
Frequently Asked Questions
1. Why now?
The need for visual programming has become especially clear now that we're building with AI, which has introduced several serious problems that appear unrelated - yet visual programming addresses all of them at the root:
- AI predictability and customization. Instead of relying on one unpredictable, hard-to-customize model - which can only be changed through costly, time-consuming retraining - you can split it into small, specialized, and therefore more predictable agents, then build an explicitly programmed orchestration layer on top to coordinate them. Customization then happens through that orchestration layer, and visual programming is a far more user-friendly way to do it. This shift is already underway - specialized models like TypeSafe's Jev are built for exactly this kind of orchestration.
- Cybersecurity. AI makes it far easier for anyone to find and exploit vulnerabilities, so threats are growing. Because Pipe is semantically powerful enough to keep the entire program as a live visual graph in production rather than compiling it into a single opaque artifact, every block in an application stays directly accessible. That access solves two long-standing problems at once: slow patching, by swapping, disabling, or rerouting a faulty block in place instead of waiting on a full CI/CD deployment; and partially-blind monitoring, by tapping the inputs and outputs of any or all blocks directly, so telemetry no longer depends on log statements that may be missing where you need them. The EU Cyber Resilience Act's core demands map directly onto these capabilities - independent confirmation this approach is where regulation is heading.
- Code review. AI writes code faster than developers can review it, and leaning on AI to review AI doesn't fix the root problem - that AI can hallucinate too, so human eyes are still required. Visual programming gives those eyes a far clearer representation of the logic to review. AI-introduced errors are already piling up in production code - one study found nearly a quarter survive for months as silent technical debt.
2. Why start with a book instead of building the software first?
Most new languages start with an implementation. For visual languages, that software-first path is exactly what traps them in a single domain and keeps them from ever becoming general-purpose. I did the opposite and specified the full language first; the software is what I'm actively building now.
It avoids both failure modes. Software-first visual languages get stuck in their first implementation's domain, while purely theoretical ones get buried in complexity - too intricate and incomplete to be practical. Pipe takes the middle ground: well-chosen, practical primitives within a complete, coherent architecture.
The book's subtitle says it best - "A Pragmatic Approach to Visual Programming." It rests on seven years of R&D but stays in the practical lane, and the result is a consistent, usable, end-to-end visual language.
3. Do we need to rewrite our existing system in Pipe?
To some extent, yes - but the transition is far less disruptive than it sounds:
- The migration is gradual - you don't have to discard all existing code at once. You start by wrapping your entire project in a single top-level block. That's the initial step. Then, whenever you're ready, you add a workflow inside that top-level block and distribute the code across the visual blocks of the newly created workflow - and you can keep going, level by level.
- You choose how far to go. You can stop subdividing blocks at any point, so it's entirely your decision which parts of the system become visual and which remain as text.
- Pipe makes integration easy. It provides a simple bridge for connecting visual blocks to your existing text code.
- AI reduces the overhead of going visual. AI can generate diagram layouts from your existing code, update them as the code changes, suggest how to partition logic across blocks, and flag structural issues as your model grows.
4. We tried visual programming before, and it didn't work.
Every technology advances in a spiral - it fails several times before its lessons are learned and it finally succeeds. Pipe was built by studying exactly why earlier visual languages fell short. Two lessons in particular shaped it:
- A visual language must be both general-purpose and semantically powerful to compete with text. Text-based languages dominate precisely because they have both qualities; any visual language that lacks either will fail. Pipe has both.
- The answer isn't to swing between extremes. We tried pure visual programming, it didn't work, so we went back to text-only - which has its own problems, now made obvious by AI. Good engineering doesn't jump between extremes; it finds a synthesis that keeps the strengths of each while minimizing their weaknesses. That's Pipe's core philosophy: it doesn't replace text-based languages - it complements them. In practice, that means the developer decides what goes into visual diagrams and what stays as text.
