Model Weave: Markdown-based ER / Class / DFD modeling in Obsidian

Share & showcase
1

Plugin/Theme Disclaimer

Is this project open source? Yes
Is this project completely free? Yes
Is this project vibe-coded beyond the author’s ability to comprehend how it works? No
Community Directory: Model Weave - Obsidian Plugin

GitHub:

Disclaimer:
I am the author of this plugin.

Model Weave — text-first modeling for software design in Obsidian

Hi everyone,

I would like to share my Obsidian plugin, Model Weave.

Model Weave is a text-first modeling plugin for Obsidian.
Markdown model files are the source of truth, and diagrams, previews, diagnostics, and PNG exports are generated from those Markdown files.

The plugin is currently focused on software and design modeling workflows, including:

  • Class models
  • ER models
  • DFD / flow-oriented models
  • Data objects
  • Experimental formats such as screens, app processes, rules, mappings, code sets, and messages

The main idea is to keep design information in Markdown, while using generated views for review, navigation, and visualization.

Why I built it

I wanted a lightweight way to manage software design models inside Obsidian without making diagrams the source of truth.

Instead of editing a diagram directly, the Markdown file remains the canonical design asset.
The plugin then generates visual views from that text.

This makes it easier to:

  • keep design documents in a vault
  • manage them with Git
  • review relationships visually
  • export diagrams as PNG
  • use Obsidian links and Markdown-based workflows
  • combine human-written notes with AI-assisted drafts

Recent dogfooding experiment

Recently, I have been using Model Weave to model Model Weave itself.

This helped me explore a workflow where AI generates or updates structured Markdown design models from source code and documentation, while a human reviews the result.

One important lesson was that AI-generated design models need clear structure and validation rules.
For example, Markdown table headers must remain compatible with the expected model format, and model elements are much more useful when they can link back to the source code they describe.

In recent versions, I have also been improving workflows around Source Links and code jumping, so a model can act not only as a diagram, but also as a map back to the implementation.

Feedback welcome

I would be happy to hear feedback from people who use Obsidian for:

  • software design notes
  • architecture documentation
  • Markdown-based modeling
  • AI-assisted knowledge work
  • reverse engineering or source-code documentation

I will keep future updates about this plugin in this thread.

2

Model Weave 0.1.4 has been released.

This update focuses on startup performance and documentation improvements.

Changes:

  • Improved startup performance with lightweight indexing and lazy parsing.

  • Reduced false unresolved-member warnings when models are still shallow-loaded.

  • Updated README / README_JP with Source Links, localSourceRoot, and performance notes.

Model Weave is now available from Obsidian Community Plugins, and you can update from Obsidian’s plugin settings.

1 Like
3

Model Weave 0.1.5 / 0.1.6 update

Hi everyone,

I released Model Weave 0.1.6.

I missed posting the previous 0.1.5 update here, so this is a combined update for both 0.1.5 and 0.1.6.

0.1.5 highlights

Version 0.1.5 focused mainly on improving the connection between Markdown design models and the implementation files they describe.

The main addition was the Source Links workflow.

Model files can include a ## Source Links section to point to related source files, tests, configuration files, SQL files, sample data, or other local references.

When localSourceRoot is configured, relative Source Links can be resolved outside the Obsidian vault, and the preview can show the original path, resolved path, status, notes, and actions such as copying or opening the path.

This is especially useful when using Model Weave as a lightweight map from design models back to source code.

0.1.6 highlights

Version 0.1.6 continues improving the modeling and preview experience.

Main changes include:

  • Added / improved app process business flow support
  • Added related documentation and samples for app process business flow modeling
  • Improved Mermaid chart readability in dark mode
  • Improved fit behavior for wrapped class cards in previews

The app process business flow work is part of a longer direction for Model Weave: representing not only static structures such as Class / ER / DFD models, but also business processes, screens, rules, mappings, and data flow relationships in Markdown.

Dogfooding model

I have also been dogfooding Model Weave by modeling Model Weave itself.

The dogfooding model is useful as an example of how Model Weave can be used to map relationships between:

  • plugin features
  • Markdown model formats
  • documentation
  • source files
  • future design ideas
  • AI-assisted documentation workflows

Dogfooding repository:

Why this matters

Model Weave is intended to keep Markdown as the source of truth, while diagrams, previews, diagnostics, and PNG exports are generated views.

The recent Source Links and app process improvements are steps toward making the model useful not only as a diagram, but also as a reviewable map between:

  • design notes
  • structured Markdown models
  • business flow / process definitions
  • implementation files
  • AI-assisted documentation workflows

Feedback is welcome, especially from people using Obsidian for software design notes, architecture documentation, business process modeling, or source-code documentation.

4

Model Weave 0.1.8 released

Model Weave 0.1.8 has been released.

Model Weave is an Obsidian plugin for managing text-first software design models in Markdown, with generated previews, diagrams, diagnostics, relationships, and source links.

This release includes the changes from 0.1.7 and 0.1.8 since the previous public release.

What is new

Relationship View

Model Weave can now show relationships around the current model more clearly.

The Relationship View helps you check:

  • models referenced by the current file
  • models that reference the current file
  • unresolved references
  • related Source Links

This makes it easier to navigate a growing set of design documents and review the impact of changes.

CodeSet / State Usage

CodeSet values and state-like values can now be tracked more effectively.

This helps answer questions such as:

  • where a status value is used
  • which screen or process depends on a state
  • which flow branch uses a specific value
  • whether a value appears to be unused or inconsistent

This is useful for business statuses, UI states, process conditions, and internal workflow states.

Improved documentation

The documentation has been updated and reorganized.

This includes:

  • clearer onboarding documentation
  • command reference improvements
  • expanded format specifications
  • English and Japanese documentation for major formats

The goal is to make Model Weave easier to understand and easier to try without needing to learn every format first.

Summary

This release improves Model Weave as a tool for navigating relationships, checking impact, and keeping Markdown-based design documents useful as a structured source of truth.

If you are using Model Weave for existing design notes, source-linked documentation, or AI-assisted modeling, 0.1.8 should make the model relationships and format guidance easier to work with.

5

Model Weave 0.1.9 has been released.

Model Weave is an Obsidian plugin for reading Markdown-based design information as diagrams, previews, diagnostics, and source links.

This release focuses on improving Mermaid rendering and the app_process / Business Flow experience.

Main changes

Added Mermaid Detail views

Class / ER related models now have a more detailed Mermaid Detail view in addition to the existing lightweight Mermaid view.

Supported targets:

  • Class
  • Class Diagram
  • Entity
  • ER Diagram

The existing Mermaid view remains useful for overview diagrams, while Mermaid Detail view shows more information such as attributes, types, PK/FK markers, and relationships.

The Custom renderer is still available for detailed review, diagnostics, and navigation.

Added Mermaid Source panel

Mermaid-based renderers now include a collapsible Mermaid Source panel.

You can copy the generated Mermaid code block and paste it into normal Obsidian Markdown notes or documentation. This makes it easier to reuse diagrams outside the Model Weave preview.

Improved app_process / Business Flow

The app_process Business Flow preview has been improved.

You can now write the main process order in Steps, and use Flows only for explicit connections such as branches, merges, loops, exceptions, and condition labels.

Main improvements:

  • Node shapes based on Steps.kind
  • Implicit flow generation from Steps row order
  • Explicit branches, merges, loops, and exception paths using Flows
  • Clearer display priority between Flows.label and Flows.condition
  • Improved display of conditions that contain Wikilinks

This makes it easier to start with a simple sequential flow and then add branches or conditions only where needed.

Cleaned up render mode behavior

The initial render mode behavior has been clarified.

  • frontmatter render_mode is prioritized
  • if omitted, the format-specific default render mode setting is used
  • renderer switching in the toolbar is treated as a temporary change for the current view
  • unsupported render_mode values show a warning and fall back safely

Future work

Mermaid color grouping by kind / area / layer, Mermaid click navigation, Sequence Diagram, and State Transition Diagram are planned for future versions.

GitHub Release:

6

Model Weave 0.1.10 released

Model Weave 0.1.10 is now available.

Fixed

  • Fixed lower pane section render order.

Documentation and samples

  • Aligned DFD diagram format documentation with the current parser schema.
  • Aligned Mapping format documentation with the current parser schema.
  • Added a minimal schema-driven relations sample using schema: model_relations_v1.
  • Updated sample documentation.

Release assets

  • Release assets are now built and uploaded by GitHub Actions.
  • Added artifact attestations for release assets.

This release is mainly a maintenance and documentation quality release, but it also improves the reliability of future releases and keeps the public format documentation closer to the actual implementation.

The documentation updates were found through source-driven dogfood validation, where Model Weave was used to check its own model and format examples.

7

Model Weave 0.1.11 has been released.

This is a maintenance release focused on compatibility, diagnostics, and preview display quality.

Changes

  • Fixed app_process Mermaid label handling so escaped display characters and visible punctuation are preserved more safely.
  • Added shared display text decoding for app_process labels.
  • Fixed data_object parsing so ## Source Links is treated as a section boundary after ## Fields.
  • Removed active display: contents usage for better Obsidian compatibility.
  • Improved Japanese localization coverage for user-facing diagnostics and warning messages.
  • Removed repetitive supported-type preview description text.
  • Fixed compact Screen target cards so link text is no longer clipped.

Next

I also checked the Obsidian community plugin review warnings for this release. The next maintenance focus will be introducing local Obsidian compatibility lint checks and then reducing compatibility warnings step by step.

8

Model Weave 0.1.12 is now available.

This is a feature-rich update focused on Domain modeling and visual readability.

New in 0.1.12

  • Reusable domains files
  • Integrated domain_diagram view
  • Reusable color_scheme files
  • DFD Domain grouping with local ## Domains and Objects.domain
  • Color Scheme support for Domains, Domain Diagram, DFD, and Business Flow
  • Applied Color Scheme display in the preview
  • PNG export support for Domains and Domain Diagram

One of the biggest improvements in this release is the new Color Scheme support.
It helps diagrams communicate structure more clearly and makes the modeling views much easier to scan.

The screenshot below shows the current view together with the applied Color Scheme, so you can immediately understand both the diagram and the active kind-color mapping.

image
image2062×1189 282 KB

image
image2062×1189 269 KB

GitHub release:

Feedback and use cases are always welcome.

9

Model Weave 0.1.13: Domain Sources and improved model readability

Model Weave 0.1.13 has been released.

This update focuses on making models easier to organize, reuse, and read across different diagram types.

The main addition is Domain Sources.

With Domain Sources, shared Domain definitions can be written once and reused from multiple models, such as:

  • domain_diagram

  • dfd_diagram

  • app_process

This makes it easier to describe a system not only as individual diagrams, but as a connected model.

Domain Sources

domain_diagram, dfd_diagram, and app_process can now refer to shared Domain definitions.

For example, you can define areas such as “Application”, “Data”, “External System”, “Preview Pipeline”, or “Renderer” in a domains file, then reuse them from different views.

This helps keep diagrams consistent when the same functional areas appear in multiple models.

image
image2223×1590 344 KB

DOMAINS-MW-ARCHITECTURE__area
DOMAINS-MW-ARCHITECTURE__area3055×1752 224 KB

DOMAIN-DIAGRAM-MW-ARCHITECTURE__tree
DOMAIN-DIAGRAM-MW-ARCHITECTURE__tree5287×796 252 KB

Domain-based DFD grouping

DFD objects can now use Objects.domain.

When Domain hierarchy is defined, the DFD can be rendered with domain-based grouping.

This makes larger data-flow diagrams easier to read because objects are visually organized by functional area.

image
image2178×1590 387 KB

DFD-MW-CORE-L0__mermaid
DFD-MW-CORE-L0__mermaid2325×3269 433 KB

Domain-based app_process flow

app_process steps now support Steps.domain.

This replaces the older lane-style usage for new models, while keeping lane as a legacy fallback.

The result is a business-flow style view that can share the same Domain definitions used by DFDs and Domain Diagrams.

image
image2182×1680 382 KB

PROC-MW-PREVIEW-RENDER-MODEL__business-flow
PROC-MW-PREVIEW-RENDER-MODEL__business-flow1920×2620 263 KB

Color Scheme improvements

Domain groups can also use Color Scheme settings.

This means the same kind of Domain, DFD object, or app_process step can have consistent visual styling across views.

image
image2158×1560 376 KB

UI and documentation improvements

This release also includes several refinements:

  • render mode cleanup for domains / domain_diagram

  • improved setting labels and language switching behavior

  • many i18n fixes where English UI still showed Japanese text

  • better preview summary labels

  • Screen preview height fixes

  • updated templates and format documentation

Why this matters

Model Weave is moving toward a model-first way of reading and maintaining systems.

Instead of treating each diagram as a separate document, Domain Sources make it easier to connect multiple views around the same conceptual structure.

This is especially useful for:

  • source-code reverse engineering

  • maintenance documentation

  • understanding existing systems

  • keeping Markdown-based models consistent over time

The next step is dogfooding: using these features in the Model Weave dogfood vault to show how Domains, app_process, DFD, and Source Links can work together as a practical code-reading map.