The first version of Markdy was a general-purpose animation language. You could place actors, move them around with imperative commands, and time everything by hand. It was flexible — and that flexibility was the problem. The most memorable early demos were little character vignettes, and while they proved the engine could animateanything, they didn't show what the tool was actually for.
The feedback that reshaped the roadmap
When Markdy reached a wider developer audience, the signal came back loud and consistent. People liked the idea of text that turns into motion, but the reaction to the demos was blunt: show me something I'd actually animate. Over and over, the concrete requests pointed at the same thing:
- System diagrams, not skits. "I was hoping for diagrams of actors in the systems sense."
- Real infrastructure flows. A browser talking to a server; a request walking through an API, a cache, and a database.
- Dataflow paths. Client → API → edge → business layer → datastore, animated step by step.
- Boxes and components, not emoji characters, as the primary building blocks.
Taken together, that feedback wasn't asking for a better skit engine. It was asking for a different product: a focused way to draw and animate architecture. So we changed direction.
What "diagram-native" means now
Today Markdy is diagram-native. Instead of positioning shapes by pixel and scripting every movement, you declare the meaning of your system — its nodes, groups, and the flows between them — and the engine handles layout, edge routing, and timing. The old imperative, hand-placed syntax is gone; the language now speaks in semantic diagram modes rather than pixel coordinates.
scene theme=editorial type=architecture
layout LR
browser Web
service API "Gateway"
cache Redis
database DB "PostgreSQL"
beat create:
show $nodes stagger=80ms
Web -> API "POST /shorten" -> DB "store slug"
API -> Redis "warm cache"
beat visit:
Web -> API "GET /a7Xk9" -> Redis "GET slug"
focus Redis zoom=1.15
Redis -> Web "302 redirect"
That's a complete, runnable scene. There are no coordinates, no per-frame commands, and no timeline to micromanage. You describe the system once and get an animated architecture diagram that lays itself out and plays the request path. For process, hierarchy, lifecycle, call-order, and radial signal stories, switch the scene to flowchart, tree, state, sequence, orconstellation. Paste it into theinteractive playground to see it move.
Why the constraint is the feature
Narrowing the language sounds like giving something up, but it's what makes the rest work:
- Layout and canvas sizing are automatic. Because nodes carry semantic types —
service,cache,database,browser— the engine automatically places components, routes orthogonal edges, and calculates the optimal canvas aspect ratio without you tuning pixels or canvas resolutions. - Diffs stay readable. A change to the architecture is a one-line change to the text, so it reviews cleanly in a pull request instead of as a re-exported image.
- LLMs get it right. A small, semantic vocabulary is far easier for Claude, ChatGPT, Gemini, or Copilot to generate correctly than freeform drawing commands — seeAI-generated architecture diagrams.
- The output is honest. The tool now demonstrates exactly what it's good at: walking a viewer through a real system, one beat at a time.
Where it fits
Static diagram-as-code tools like Mermaid, PlantUML, D2, and Graphviz remain excellent for still charts in a README. Markdy is for the moment a single frame isn't enough — when you need to play a request path, a cache-miss fallback, or a deploy pipeline. If you're weighing the two, theMarkdy vs Mermaid comparison lays out when to reach for motion, andanimated diagrams as code covers the version-control story.
The takeaway
Good feedback is rarely comfortable, but it's clarifying. Developers didn't want a toy that could animate anything — they wanted a sharp tool for the thing they draw every week: systems. Markdy is built around that now, and the whole language is better for the focus. The fastest way to feel the difference is toopen the playground, pick an architecture scene, and watch your system explain itself.