Ramblings in time and measure

Over the past few months, I’ve been working on a diagramming framework called Runiq, and I’m excited to finally release it.

At a glance, it sits in the same space as tools like Mermaid and PlantUML. But the goal wasn’t to recreate those tools, it was to rethink how diagrams are defined.

Most diagram tools force you into a specific type: Flowchart. UML. Architecture diagram, etc. Each with its own syntax, rules, and limitations.

But real systems don’t fit neatly into those categories.

Runiq is built around a different idea: diagrams should be composable.

What that means in practice

Runiq uses a shared core system, where many diagram types live inside a common “diagram” profile.

Within that, you can:

• Mix shapes from different diagram styles
• Combine structure, flow, and relationships in one diagram
• Reuse styling and layout concepts consistently

For example, you might combine:

• flowchart-style logic
• C4-style architecture elements
• annotations and relationships
• pie charts, etc

all in a single diagram.

Domain boundaries (important)

Not everything is mixed together. Some diagram types live in their own profiles, where they have specialized behavior, such as:

• Sequence diagrams
• Timeline diagrams
• Family trees (pedigree diagrams)
• Technical schematics (electrical, digital, etc.)

These are intentionally separate, because they follow different rules and layouts.

So the model is:

👉 Composable where it makes sense
👉 Separate where the domain requires it

What makes Runiq different

• Composable diagrams (within a shared system)
  You’re not locked into a single diagram type for most use cases.
• Consistent syntax across domains
  Even when profiles differ, core concepts like styling and structure carry across.
• Clean SVG output
  No HTML-based rendering tricks. Just standards-compliant SVG that works in slides and exports.
• Glyphsets (quick diagram templates)
  Built-in “SmartArt” style layouts (cycles, hierarchies, matrices, etc.) for fast diagram creation.
• One system, multiple domains
  Software diagrams, infrastructure, and even technical schematics share the same underlying approach.

Tradeoffs (being honest)

Runiq isn’t strictly “better” than existing tools in every case.

• Mermaid’s markdown-style syntax is lighter weight
  Great for quick inline diagrams.
• PlantUML has a mature ecosystem
  Especially for well-established diagram types.
• Not all diagram types are composable
  Some domains (like schematics or sequence diagrams) are intentionally separate.

Runiq leans toward:

• more structure (DSL instead of markdown-like syntax)
• more flexibility (composition where appropriate)

What’s available

• DSL + parser + SVG renderer
• NPM packages and CLI
• Online editor
• Documentation and examples

Docs: https://docs.runiq.org/
Editor: https://editor.runiq.org/

Why I built this

I’ve spent a lot of time working with diagram tooling in general, and was even a member of the MermaidJS team, so I’ve seen firsthand where these tools shine, and where they start to feel a little rigid.

Runiq grew out of that experience.

I kept running into the same friction. Switching diagram types meant switching syntax, tools, and mental models. As systems grew, adding new features became harder, and supporting new diagram types often meant building entirely new structures from scratch.

Runiq is an attempt to unify that into a single system, without forcing everything into one box.

Feedback welcome

This is an early release, and I’d really value feedback, especially from people who:

• use Mermaid or PlantUML heavily
• maintain docs-as-code systems
• work with complex or mixed-type diagrams