Concepto DSL: Building a Custom IDE from Scratch
How I built a visual programming IDE that generated production code for 100+ apps across 10+ platforms
The Problem
Most IDEs force you to think in syntax, not concepts. I needed something different—a way to go from idea to production code without losing the mental model.
The solution: Build a custom IDE that uses mindmaps as the programming interface.
In 2007, I forked Freemind and built Concepto—a visual programming environment where mindmap nodes compile directly into working applications. No traditional code writing required.
Why mindmaps? They're how humans naturally organize complex information. Non-linear, visual, easy to refactor. Perfect for representing both application structure and logic flow.
First Production Use
The test: Could this approach ship real products for paying clients?
Built the first version for creating mobile websites in my Creador WAP framework. Drew concepts in a mindmap, hit compile, deployed to production.
Year one results:
- 100+ mobile websites shipped to production
- Clients: Discovery Networks, Movistar, Sony
- Zero traditional code written
- Development speed: 10x faster than conventional approach
The breakthrough wasn't just speed—it was maintaining conceptual clarity from idea through deployment. The mindmap you saw was the actual source code.
Scaling the Approach
Founded Creador S.A. to productize Concepto. Initial plan: sell licenses to developers.
Reality check: Everyone loved the demo. Nobody bought licenses.
Pivot: Use Concepto as our competitive advantage. Build client products faster than traditional agencies.
Result: Ran Creador for 13 years as CEO, powered entirely by this custom toolchain. The IDE wasn't the product—it was the engine that made everything else possible.
Multi-Platform Code Generation
The real power wasn't mobile websites—it was the compiler architecture that could target any platform.
The approach: Domain Specific Languages (DSLs) for each target platform. Same mindmap, different output.
Platform expansion:
- J2ME/Nokia → MoSync (C++)
- Web apps → qooxdoo framework
- Mobile apps → Appcelerator Titanium, native Swift/Java
- Backend services → Node.js, ColdFusion, Ruby
One visual model. Ten different compilation targets. Write once, deploy everywhere—actually delivered.
Key insight: The abstraction layer wasn't the problem—most visual programming tools fail because they try to be general-purpose. Concepto was opinionated about architecture patterns, which made it faster to use.
Production Applications
These aren't prototypes. These are production apps that shipped to app stores and served real users—all generated from mindmaps.
Total output: 100+ mobile applications shipped across Latin America. All compiled from the same IDE.
What I Learned
Visual programming can work—but only with constraints.
Most visual programming tools fail because they try to recreate traditional programming visually. That's backwards.
What worked:
- Opinionated architecture - Concepto enforced patterns, not just syntax
- Domain-specific - Each DSL was purpose-built for its target
- Concept-first - Think in business logic, not implementation details
- Iteration speed - See changes immediately, no compile-wait-debug loop
The real value: Maintaining the mental model from conception through deployment. No context switching between "what I want" and "how to code it."
This approach made me and my team incredibly productive. Development speed wasn't just faster—it was fundamentally different.
Impact
What this proves:
- Built a complete custom IDE that powered a company for over a decade
- Generated production-quality code across wildly different platforms
- Visual, concept-driven development works at scale
- Achieved 10x productivity gains compared to traditional development
The takeaway: Don't accept tool limitations. If existing IDEs don't match how you think, build your own.
Let's Build Something
If you're building developer tools, code generation systems, or domain-specific languages, I can help.
I've built production compilers, designed DSLs, and shipped systems that generated millions of lines of working code. I understand the complexities of abstraction layers, multi-target compilation, and building tools that developers actually want to use.
Ready to discuss your project? Let's talk.