Keep your Obsidian vault organized, reliable, and useful as it grows.
Forge helps you maintain consistent metadata, repair structural drift, standardize notes, and build more dependable Dataviews, Bases, dashboards, exports, and automation workflows.
Whether your vault holds projects, research, journals, client work, tasks, notes, or personal systems, Forge helps everything keep working together over time.
Most vaults start simple.
Then, slowly:
- fields get renamed
- tags drift apart
- templates change
- old notes stop matching new workflows
- dashboards miss results
- Dataview queries become fragile
- Bases become less useful
- exports become noisy
Forge helps keep your vault consistent without forcing you into a rigid system.
Forge provides maintenance and structure tooling for Obsidian vaults:
- Schema validation
- Vault linting
- Frontmatter normalization
- Tag normalization
- Bulk note update workflows
- Vault repair tools
- Reusable note structure validation
- Relationship indexes
- Vault exports
- Maintenance workflows
- Vault-installed documentation
- Copy-ready examples
Think of it as:
Maintenance tooling for long-lived Obsidian vaults.
Or more simply:
Forge helps your vault stay clean, consistent, and dependable over time.
Many Obsidian workflows depend on predictable metadata and structure.
That includes:
- Dataview
- Bases
- dashboards
- templates
- graph relationships
- automation workflows
- AI-assisted workflows
- note queries
- exports
When metadata is consistent, your tools can find the right notes.
When metadata drifts, your tools become unreliable.
Examples:
projectvsprojectsactivevsin-progresstypevsnote_type- missing frontmatter
- duplicated tags
- malformed YAML
- old templates mixed with new templates
Forge helps keep your vault structure predictable so your queries, Bases, dashboards, and workflows continue working months or years later.
The goal is not rigid control.
The goal is durable consistency.
Forge is useful for anyone whose vault has started to grow beyond manual cleanup.
It works well for:
- personal knowledge systems
- project vaults
- research vaults
- journals
- writing systems
- task systems
- client workspaces
- team/shared vaults
- Dataview-heavy vaults
- Bases-driven workflows
- AI-assisted note systems
You do not need a perfect vault to use Forge.
Forge is designed for real vaults: uneven, evolving, useful, and alive.
Not yet available
Copy these files into:
.obsidian/plugins/forge/
Required files:
manifest.json
main.js
styles.css
Then enable Forge in:
Settings → Community Plugins
After installation or updates, click:
Reload plugins
from the command palette so Obsidian reloads Forge and registers the latest plugin files.
Run:
Forge: Install Documentation
Forge installs a complete documentation and examples system directly into your vault.
Typical structure:
{{forge}}/
├── Docs/
├── Examples/
├── Patches/
├── Schemas/
├── Shapes/
└── Exports/
Read:
Docs/1. Start Here.md
The installed vault docs are the main Forge documentation.
They include:
- setup walkthroughs
- schema guides
- lint workflows
- repair workflows
- export documentation
- shape systems
- settings references
- troubleshooting guides
- operational examples
- copy-ready templates
The README gives the overview.
The installed docs are the field guide.
Run:
Forge: Run Vault Lint
Forge scans your vault for structural inconsistencies such as:
- missing metadata
- malformed frontmatter
- inconsistent tags
- schema violations
- stale fields
- shape mismatches
- structural drift
The results are grouped into actionable categories so you can improve your vault gradually.
Schemas define the structure you want your notes to follow.
They can describe:
- required fields
- allowed values
- note types
- review schedules
- metadata expectations
- folder rules
- tag rules
Example:
required_fields:
- name: status
type: enum
values:
- draft
- active
- archivedSchemas help keep notes predictable.
That makes Dataview queries, Bases, dashboards, exports, and automations easier to trust.
Forge validates notes against your schemas and structural rules.
Linting can detect:
- missing frontmatter
- malformed YAML
- invalid metadata
- inconsistent tags
- outdated fields
- schema violations
- stale review cycles
- shape mismatches
Forge groups findings by severity so you can prioritize structural problems incrementally instead of fixing everything at once.
Normalization keeps metadata formatting clean and predictable.
Forge can:
- sort tags
- deduplicate tags
- standardize frontmatter ordering
- normalize metadata structure
- reduce formatting drift
Small inconsistencies compound over time.
Normalization keeps the vault tidy before small cracks become weird little YAML goblins.
Detailed normalization workflows and before/after examples are included in the installed docs.
Patches are reusable operational workflows stored as markdown notes.
They can be used for:
- vault migrations
- metadata repair
- bulk edits
- note movement
- field updates
- structural cleanup
Example:
# Patch
```yaml
operations:
- op: set_field
target: "Projects/Home.md"
field: status
value: active
```Patch workflows support:
- dry runs
- backups
- restore operations
- conditional execution
Additional patch walkthroughs and repair workflows are included in the installed docs and examples.
Forge can generate repair operations from lint findings.
Repair workflows help fix:
- malformed frontmatter
- invalid fields
- missing metadata
- inconsistent tags
- structural mismatches
Repair actions are previewable and reversible.
Repair walkthroughs and recovery examples are included in the installed docs.
Shapes are reusable structural blueprints for note systems.
They help validate organization beyond simple metadata.
Shapes are useful for:
- project workspaces
- meeting notes
- research pipelines
- client records
- operational runbooks
- content workflows
Forge supports:
- recursive shape matching
- shape linting
- template refinement
- repair workflows
- dry runs
- restore support
Complete shape examples and recursive validation walkthroughs are included in the installed docs.
Forge can build relationship indexes from your notes.
This helps surface how ideas, projects, people, systems, and topics connect across your vault.
Relationship indexes make larger vaults easier to:
- navigate
- query
- audit
- visualize
- export
- use with AI workflows
Forge calls these ontology indexes because they map relationships between notes and concepts across the vault.
You do not need to be an ontology expert to use them.
Forge exports structured vault data for dashboards, AI tooling, audits, and external workflows.
Export Vault Overview generates:
vault-inventory.jsonvault-meta.jsonvault-export.md
Export Ontology Index generates relationship indexes from configured note headings.
Exports are useful for:
- AI context generation
- vault dashboards
- metadata audits
- reporting
- external integrations
- archival workflows
Additional export examples and dashboard walkthroughs are included in the installed docs.
Forge installs organized examples directly into your vault.
Examples include:
- starter schemas
- lint workflows
- patch operations
- repair examples
- shape systems
- export workflows
- maintenance routines
The examples are designed to be copied and adapted to your own vault.
Forge complements tools like:
- Dataview
- Bases
- Templater
- Metadata Menu
- QuickAdd
- dashboard notes
- AI-assisted workflows
Forge focuses on the layer underneath those tools:
clean, consistent, queryable structure.
| Command | Purpose |
|---|---|
Forge: Install Documentation |
Install vault docs and examples |
Forge: Run Vault Lint |
Validate vault structure against schemas and rules |
Forge: Validate Schema |
Validate schema configuration |
Forge: Normalize Tags |
Sort and deduplicate tags |
Forge: Normalize Frontmatter |
Reorder frontmatter consistently |
Forge: Apply Vault Patch |
Execute structured patch operations |
Forge: Vault Repair |
Generate repair operations from lint findings |
Forge: Restore Patch Run |
Restore files from previous patch backups |
Forge: Vault Maintenance |
Run maintenance workflows |
Forge: Rename Dataview Folder |
Safely update Dataview folder references |
Forge: Export Vault Overview |
Generate inventory and metadata exports |
Forge: Export Ontology Index |
Build relationship indexes from note structures |
Detailed command walkthroughs and examples are included in the installed documentation.
Forge includes dedicated settings sections for:
- General configuration
- Schema management
- Vault linting
- Patch execution
- Shapes
- Export configuration
- Maintenance
- Advanced operations
Every setting is documented in the installed vault docs.
Forge is intentionally conservative.
The plugin emphasizes:
- explicit operations
- dry-run workflows
- reversible changes
- restore support
- operational visibility
- predictable behavior
You stay in control of vault modifications.
Recommended practices:
- Use Git for large vaults
- Backup before major operations
- Test schemas incrementally
- Run linting before patch execution
- Use dry runs before repair workflows
npm install
npm run buildRelease assets are generated from the plugin root.
Knowledge systems naturally drift over time.
Fields change. Templates evolve. Workflows shift. Old notes stop matching new structures.
Forge exists to help your vault remain:
- Consistent
- Queryable
- Repairable
- Reliable
- Maintainable
Not through rigidity.
Through sustainable structure and practical maintenance over time.
MIT