isHistory — Mapping the Digital Past

The Complete Markdown Showcase: Every Element, Every Variant

ishistory@proton.me (Ishaan) — Thu, 18 Jun 2026 00:00:00 GMT

Overview

This post is a living style guide for the isHistory markdown pipeline. Every element that the pipeline can render is exercised below, with multiple variants where applicable. If you're authoring a new post and want to see how a particular syntax will look, find it here.

The pipeline supports:

CommonMark — the baseline spec (headings, paragraphs, lists, code, links, images, blockquotes, horizontal rules)
GFM (GitHub Flavored Markdown) — tables, task lists, strikethrough, autolinks, deletion/insertion
Obsidian Flavored Markdown — callouts (> [!note], > [!tip], > [!important], > [!warning], > [!caution]), wiki-links ([[target]], [[target|alias]])
KaTeX math — inline ( $...$ ) and display ($$...$$) math
rehype-pretty-code — Shiki-powered syntax highlighting with dual themes (light/dark), line highlighting, line numbers, diff syntax, code block titles
Extended HTML elements — <kbd>, <mark>, <abbr>, <details>, <summary>, <dl>, <sub>, <sup>, <del>, <ins>, <cite>, <q>, <address>

Headings (h2 through h6)

The page title is the only <h1>. Inside the article body, headings start at h2. The TOC in the sidebar auto-generates from h2 and h3.

This is an h3

This is an h4

This is an h5

This is an h6

Heading anchor links (the chain icon) appear on hover to the left of every h2–h6. Clicking one updates the URL hash for deep-linking.

Paragraphs and Inline Formatting

A standard paragraph. Markdown wraps consecutive lines into a single paragraph. To start a new paragraph, leave a blank line between blocks.

A second paragraph immediately after. The vertical rhythm comes from the Tailwind Typography plugin's default prose-lg spacing.

Bold text uses double asterisks. Alternatively, double underscores. Italic text uses single asterisks. Alternatively, single underscores. Bold italic uses triple asterisks. ~~Strikethrough~~ uses double tildes (GFM). Inline code uses single backticks.

You can also use the legacy HTML tags: bold, italic, ~~strikethrough~~, underline, teletype, small text, big text.

Links

Inline link: isHistory homepage. Link with title attribute (hover): Astro docs. Reference-style link: Astro. Auto-link (bare URL): https://astro.build.

Internal links use relative paths: blog index, series index. Wiki-links (Obsidian-style) also work: [[astro-website-cms-obsidian-plugin]] resolves to the file's permalink. Wiki-links with aliases: [[astro-website-cms-obsidian-plugin|the CMS post]].

External links automatically get target="_blank" and rel="noopener noreferrer" via rehype-external-links. Example: GitHub.

Emphasis and Semantic Inline Elements

HTML abbreviations get a dotted underline and a tooltip on hover. Ctrl + K opens search. Esc closes modals.

Use mark to highlight text. Use cite for citation titles. Use inline quotes for short quotations (auto-wrapped in curly quotes). Use sample output for computer output.

Subscript: H₂O. Superscript: E = mc². Combination: a_n² + b_n² = c_n².

~~Deleted text~~ shows removals. Inserted text shows additions. These are useful for editorial revisions.

Lists

Unordered List

First item
Second item
- Nested item (level 2)
  - Nested item (level 3)
- Back to level 2
Third item

Ordered List

First item
Second item
Third item
1. Nested ordered (level 2)
2. Another nested
Fourth item

Mixed List

Ordered item one
- Unordered nested under it
- Another unordered
Ordered item two
- More nesting
  1. Deeply nested ordered

Task List (GFM)

Completed task
Incomplete task
Another completed task with bold and italic text inside
A task with a link inside

Task list items get custom checkboxes — checked items have a strikethrough on their text.

Definition List

Astro: A modern static site generator that ships zero JavaScript by default.
Tailwind CSS: A utility-first CSS framework for rapid UI development.
KaTeX: A fast, easy-to-use JavaScript library for TeX math rendering on the web.

Blockquotes — Every Variant

Simple Blockquote

This is a simple blockquote. It has one paragraph and no nesting.

Multi-Paragraph Blockquote

First paragraph of the blockquote.

Second paragraph, separated by a blank line inside the blockquote.

Nested Blockquote

Outer blockquote, level 1.

Inner blockquote, level 2.

Still inside the inner blockquote.

Blockquote with Attribution

The best way to predict the future is to invent it.

— Alan Kay

Blockquote with Rich Content

Bold, italic, ~~strikethrough~~, inline code, and a link — all work inside blockquotes.

Even a nested list:

Item one

Item two

And a code block:
const x = 42;

Pull Quote (auto-styled)

Design is not just what it looks like and feels like. Design is how it works.

— Steve Jobs

All blockquotes get the editorial pull-quote treatment: large italic text, decorative opening quotation mark, gradient background, indigo left border, and subtle shadow.

Tables — Every Variant

Simple Table

Name	Type	Description
Astro	Framework	Static site generator
Tailwind	CSS	Utility-first framework
KaTeX	Library	Math rendering

Table with Alignment

Left aligned	Center aligned	Right aligned
left	center	right
longer text	longer text	longer text
short	short	short

Table with Inline Formatting

Feature	Syntax	Result
Bold	`text`	text
Italic	`text`	text
Strikethrough	`~~text~~`	~~text~~
Inline code	`code`	`code`
Link	`[text](url)`	text

Table with Many Rows (Zebra Striping)

Tables with 4+ rows get automatic zebra striping on alternating rows. Hover highlights the row with a subtle indigo tint.

#	Era	Year	Notable Event
1	Pre-history	1843	Ada Lovelace's first algorithm
2	Pre-history	1936	Turing machine paper
3	Birth of AI	1956	Dartmouth Conference
4	First winter	1974	Lighthill Report
5	Expert systems	1980	Rise of MYCIN, XCON
6	Second winter	1987	LISP machine market collapse
7	Deep learning	2012	AlexNet wins ImageNet
8	Transformer	2017	"Attention Is All You Need"
9	Generative AI	2022	ChatGPT launches

Wide Table (Horizontal Scroll)

Wide tables overflow horizontally on small screens. On desktop, they fit within the prose column.

Column A	Column B	Column C	Column D	Column E	Column F	Column G	Column H	Column I	Column J
1	2	3	4	5	6	7	8	9	10
alpha	beta	gamma	delta	epsilon	zeta	eta	theta	iota	kappa

Callouts — Every Type

The rehype-callouts plugin (GitHub theme) supports five callout types. Each renders as a colored block with an SVG indicator and a title.

[!note] This is a note callout. Use it for neutral, informational asides that don't warrant stronger emphasis.

[!tip] This is a tip callout. Use it for helpful suggestions, best practices, or shortcuts that improve the reader's experience.

[!important] This is an important callout. Use it for information that the reader must not skip — critical context, prerequisites, or warnings about data loss.

[!warning] This is a warning callout. Use it for cautionary advice about things that could go wrong, common pitfalls, or edge cases.

[!caution] This is a caution callout. Use it for the strongest warnings — actions that are irreversible, dangerous, or violate security.

Callouts with Custom Titles

[!note] Custom Title Here When you add text after [!note] on the same line, it replaces the default "Note" title. The body of the callout goes on the next line.

[!tip] Pro Tip Custom titles make callouts more specific. Use them when the default title is too generic.

Callouts with Rich Content

[!important] Read This First Callouts support all markdown inside them:

Lists

inline code

Links

Even code blocks:
function important() {
  return 'this works inside callouts too';
}

Collapsible Callouts

[!note]- Collapsed by default (click to expand) The - after [!note] makes the callout collapsed by default. Users click the title to expand it. Useful for long asides that aren't essential to the main flow.

[!note]+ Expanded by default (click to collapse) The + after [!note] makes the callout expanded by default but collapsible. Useful for content that should be visible initially but can be hidden.

Code Blocks — Every Variant

Plain Code Block (no language)

This is a plain code block with no language specified.
No syntax highlighting is applied.

JavaScript

// A JavaScript code block with syntax highlighting
const greet = (name) => {
  console.log(`Hello, ${name}!`);
  return `Greetings, ${name}`;
};

greet('world');

TypeScript

// TypeScript with type annotations
interface User {
  id: number;
  name: string;
  email?: string;
}

function getUser(id: number): Promise<User> {
  return fetch(`/api/users/${id}`).then((res) => res.json());
}

Python

# Python with type hints
from typing import List, Optional

def fibonacci(n: int) -> List[int]:
    """Generate the first n Fibonacci numbers."""
    if n <= 0:
        return []
    if n == 1:
        return [0]
    fibs = [0, 1]
    for _ in range(2, n):
        fibs.append(fibs[-1] + fibs[-2])
    return fibs

print(fibonacci(10))

Bash / Shell

#!/usr/bin/env bash
# A bash script example
set -euo pipefail

PROJECT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
cd "$PROJECT_DIR"

echo "Building project..."
npm run build
echo "Deploying..."
npx wrangler pages deploy dist

JSON

{
  "name": "isHistory",
  "version": "1.0.0",
  "type": "module",
  "scripts": {
    "dev": "astro dev",
    "build": "astro build",
    "preview": "astro preview"
  },
  "dependencies": {
    "astro": "^6.0.0",
    "tailwindcss": "^4.0.0"
  }
}

CSS

/* CSS with nested selectors */
.button {
  display: inline-flex;
  align-items: center;
  padding: 0.5rem 1rem;
  border-radius: 0.375rem;
  background: #4f46e5;
  color: #ffffff;
  transition: background-color 0.2s ease;
}

.button:hover {
  background: #4338ca;
}

HTML

<!doctype html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <title>Example</title>
  </head>
  <body>
    <main>
      <h1>Hello, world!</h1>
      <p>This is an HTML code block.</p>
    </main>
  </body>
</html>

YAML

# YAML frontmatter example
title: "Sample Post"
description: "A sample post for demonstration."
pubDate: 2026-06-18
tags:
  - Markdown
  - Reference
draft: false

SQL

-- SQL query example
SELECT
  u.id,
  u.name,
  COUNT(p.id) AS post_count,
  MAX(p.created_at) AS last_post
FROM users u
LEFT JOIN posts p ON p.author_id = u.id
WHERE u.created_at >= '2026-01-01'
GROUP BY u.id, u.name
HAVING COUNT(p.id) > 0
ORDER BY post_count DESC
LIMIT 10;

Code Block with Title (filename)

import { defineConfig } from 'astro/config';

export default defineConfig({
  site: 'https://ishistory.pp.ua',
  integrations: [],
});

Code Block with Line Highlighting

Use {1,3-5} syntax to highlight specific lines:

const config = {
  site: 'https://ishistory.pp.ua',
  integrations: [],
  markdown: {
    shikiConfig: { theme: 'github-dark' },
    syntaxHighlight: 'shiki',
  },
};

Code Block with Line Numbers

Use showLineNumbers to add line numbers:

function quicksort(arr) {
  if (arr.length <= 1) return arr;
  const pivot = arr[0];
  const left = arr.slice(1).filter((x) => x < pivot);
  const right = arr.slice(1).filter((x) => x >= pivot);
  return [...quicksort(left), pivot, ...quicksort(right)];
}

Diff Code Block

Use diff language to show additions/removals:

function greet(name) {
-  console.log("Hello, " + name);
+  console.log(`Hello, ${name}!`);
+  return `Greetings, ${name}`;
}

greet("world");

Multiple Features Combined

Title + line numbers + line highlighting:

export function factorial(n: number): number {
  if (n < 0) throw new Error('Negative input');
  let result = 1;
  for (let i = 2; i <= n; i++) {
    result *= i;
  }
  return result;
}

export function binomial(n: number, k: number): number {
  return factorial(n) / (factorial(k) * factorial(n - k));
}

Inline Code

Inline code uses single backticks: const x = 42. Code inside a sentence: Array.prototype.map(). With special characters: <div className="foo" />. With backticks inside: `single backtick`.

Math — KaTeX

The pipeline supports inline math with $...$ and display math with $$...$$. Math is rendered by KaTeX.

Inline Math

The Pythagorean theorem: $a^2 + b^2 = c^2$. The area of a circle: $A = \pi r^2$. Euler's identity: $e^{i\pi} + 1 = 0$. A quadratic equation: $x = \frac{-b \pm \sqrt{b^2 - 4ac}}{2a}$.

Inline math inherits the surrounding text color and respects line-height.

Display Math

$$ \int_{-\infty}^{\infty} e^{-x^2} , dx = \sqrt{\pi} $$

$$ \sum_{n=1}^{\infty} \frac{1}{n^2} = \frac{\pi^2}{6} $$

$$ \frac{\partial f}{\partial x} = \lim_{h \to 0} \frac{f(x+h) - f(x)}{h} $$

Matrices

$$ \begin{bmatrix} a & b \ c & d \end{bmatrix} \begin{bmatrix} x \ y \end{bmatrix}

\begin{bmatrix} ax + by \ cx + dy \end{bmatrix} $$

Aligned Equations

$$ \begin{aligned} \nabla \times \vec{B} &= \mu_0 \vec{J} + \mu_0 \varepsilon_0 \frac{\partial \vec{E}}{\partial t} \ \nabla \times \vec{E} &= -\frac{\partial \vec{B}}{\partial t} \ \nabla \cdot \vec{B} &= 0 \ \nabla \cdot \vec{E} &= \frac{\rho}{\varepsilon_0} \end{aligned} $$

Cases (Piecewise Functions)

$$ f(x) = \begin{cases} x^2 & \text{if } x \geq 0 \ -x^2 & \text{if } x < 0 \end{cases} $$

Summation and Products

$$ \prod_{i=1}^{n} i = n! \qquad \sum_{k=0}^{n} \binom{n}{k} = 2^n $$

Limits and Calculus

$$ \lim_{n \to \infty} \left(1 + \frac{1}{n}\right)^n = e \approx 2.71828\ldots $$

Greek Letters and Symbols

$$ \alpha, \beta, \gamma, \delta, \epsilon, \zeta, \eta, \theta, \iota, \kappa, \lambda, \mu, \nu, \xi, \pi, \rho, \sigma, \tau, \upsilon, \phi, \chi, \psi, \omega $$

$$ \Gamma, \Delta, \Theta, \Lambda, \Xi, \Pi, \Sigma, \Upsilon, \Phi, \Psi, \Omega $$

Math with Text

$$ P(\text{Event}) = \frac{\text{favorable outcomes}}{\text{total outcomes}} \times 100% $$

Horizontal Rules

A horizontal rule creates an editorial section break — a gradient line with a centered indigo dot. Three variants of syntax all produce the same result:

Above is a horizontal rule using three hyphens.

Above is a horizontal rule using three asterisks.

Above is a horizontal rule using three underscores.

Images

Astro logo (placeholder):

Images get a rounded border and subtle box-shadow. Long alt text appears in the figcaption styling if wrapped in a figure (using HTML).

Figures with figcaptions get centered, smaller, muted text below the image. Use this for editorial figures that need attribution or explanation.

Details and Summary (Disclosure Widget)

Click to expand — basic details element

The `

` element creates a collapsible disclosure widget. The `

` is the clickable header. Content below the summary is hidden until expanded.

Markdown works inside:

Lists
Bold and italic
Inline code

Multiple paragraphs inside details

First paragraph. Note the blank line above — it ensures proper paragraph spacing.

Second paragraph. Without the blank line, paragraphs would be squished together.

Even code blocks work:

console.log('inside a details element');

Expanded by default

Add the `open` attribute to `

` to start expanded. Users can collapse it by clicking the summary.

Addresses and Citations

Written by Ishaan
isHistory Project
Email: ishistory@proton.me
Web: ishistory.pp.ua

As Alan Turing once wrote, "We can only see a short distance ahead, but we can see plenty there that needs to be done."

Footnotes

GFM supports footnotes via the [^1] syntax[^1]. Footnotes appear at the bottom of the document with a clickable reference link[^longnote].

[^1]: This is the first footnote. Click the back arrow to return to the text.

[^longnote]: Here's one with multiple paragraphs and code.

Indent paragraphs to include them in the footnote.

```
code blocks work too
```

And back to text.

Footnotes can also be inline[^inline-note] like this.

[^inline-note]: This footnote is defined inline at the point of reference.

Combination Examples

A Callout with Math Inside

[!tip] Math in Callouts The quadratic formula $x = \frac{-b \pm \sqrt{b^2 - 4ac}}{2a}$ works inline inside callouts. So does display math:

$$\text{discriminant} = b^2 - 4ac$$

A Table with Code and Math

Operation	Code	Math
Square root	`Math.sqrt(x)`	$\sqrt{x}$
Power	`Math.pow(x, n)`	$x^n$
Sum	`arr.reduce((a,b) => a+b, 0)`	$\sum_{i=1}^{n} x_i$
Integral	n/a (numerical only)	$\int_a^b f(x) , dx$

A Blockquote with a Code Block

"Code is like humor. When you have to explain it, it's bad." — Cory House
// Even bad code can be improved
function bad() {
  return [1, 2, 3].map((x) => x * 2).filter((x) => x > 2).reduce((a, b) => a + b, 0);
}

Edge Cases

Empty Elements

A horizontal rule with no content around it:

A paragraph immediately after a horizontal rule.

Special Characters

The pipe character | in tables needs escaping: | escaped pipe | in a table cell.

Less-than < and greater-than > should be escaped in code: <div> becomes <div> in raw HTML, but inside backticks <div> is fine.

Ampersands: AT&T, Tom & Jerry, P&G. In code: if (a && b). In URLs: ?a=1&b=2.

Emojis

Standard emojis work in markdown: 🚀 rocket, ✅ check, ❌ cross, ⚠️ warning, 💡 idea, 📌 pin, 🎯 target, 📝 memo. They render with the system emoji font.

Very Long Line

This is a single paragraph that contains a very long line of text without any line breaks in the source markdown. Markdown will wrap this to fit the available width automatically based on the prose container's max-width. The 65ch optimal line length means the text wraps at approximately 65 characters per line, which is the recommended maximum for reading comfort per Baymard Institute research. Longer lines cause readers to lose their place when jumping from the end of one line to the start of the next; shorter lines force the eye to return too often, breaking rhythm. The 65ch value strikes the right balance for most body text.

Unicode and Internationalization

Latin: café, naïve, résumé, façade. Greek: α β γ δ ε ζ η θ ι κ λ μ. Cyrillic: А Б В Г Д Е Ж. Chinese: 你好世界. Japanese: こんにちは世界. Korean: 안녕하세요 세계. Arabic: مرحبا بالعالم. Hebrew: שלום עולם. Hindi: नमस्ते दुनिया. Thai: สวัสดีชาวโลก.

Right-to-left text: مرحبا بالعالم — wraps in a span with dir="rtl".

Summary

This post exercised:

6 heading levels (h1 implicit, h2–h6 in body)
Paragraphs with inline formatting (bold, italic, strikethrough, code, mark, kbd, abbr, sub, sup, del, ins, cite, q, samp, small, big, tt, u)
Links (inline, reference, auto, internal, external, wiki-link)
Lists (unordered, ordered, nested, mixed, task list, definition list)
Blockquotes (simple, multi-paragraph, nested, with attribution, with rich content)
5 callout types (note, tip, important, warning, caution) × 4 variants each (default, custom title, rich content, collapsible)
Tables (simple, aligned, with formatting, many-row, wide overflow)
Code blocks (10+ languages, with title, line highlighting, line numbers, diff, combined)
Math (inline, display, matrices, aligned, cases, summation, limits, Greek letters, with text)
Horizontal rules (3 syntaxes)
Images (inline, figure with caption)
Details/summary (collapsed, expanded, with rich content)
Addresses, citations, footnotes
Edge cases (special characters, emojis, long lines, Unicode, RTL text)

If you spot anything missing or rendering incorrectly, open an issue on the GitHub repo.

Your Astro Website Deserves a Better CMS: Meet isHistory

ishistory@proton.me (Ishaan) — Thu, 28 May 2026 00:00:00 GMT

Your Astro Website Deserves a Better CMS

How I Built isHistory CMS — an Obsidian plugin that turns your notes into a full content management system for Astro-powered websites

If you've ever built a content-heavy site with Astro, you know the framework is fast, the builds are snappy, and the content collections system is genuinely elegant. But day-to-day content management? That's another story.

Open VS Code. Navigate through folders. Manually edit YAML frontmatter. Hope you didn't miss a required field. It works — but it's not a workflow. It's a chore.

I built isHistory CMS to solve this problem. It's now an official Obsidian Community Plugin that turns Obsidian into a full CMS for Astro websites. Think of it as a spell‑checker for your blog posts — but instead of checking spelling, it checks that every post has all the information your Astro site needs to display it properly.

TL;DR – isHistory CMS gives you a visual dashboard, live frontmatter validation, one‑click pre‑flight marking, and a mobile‑friendly editorial interface — all inside Obsidian. No external servers, no API keys, your data stays in your vault.

The Problem: Managing History Content in a Static World

Building an AI history publication in Astro is fast, elegant, and delightfully developer-friendly — until you have to manage it day to day. Each post in my publication has:

A track (Articles, Profiles, or Events)
A series order code
Validation rules for frontmatter fields
A publishing status

That's a lot of metadata to juggle across dozens of Markdown files. A single typo in a frontmatter field can silently break your entire build.

The default workflow — manually editing YAML in VS Code — works, but for a content-heavy site like mine, it becomes an active burden. I built isHistory CMS to turn Obsidian into a writing-first environment where content management feels like writing, not programming.

What isHistory CMS Does

isHistory CMS is designed for the isHistory Astro project (a deep‑dive into the history of AI) but works with any Astro site that uses Content Collections.

A Visual Dashboard for Your Content

The plugin opens a full dashboard view inside Obsidian that displays every post in your content collections as interactive cards. Each card shows:

Post title
Track badge
Validation status (ready / errors)
Description
Tags
Draft status

Color‑coded left borders instantly tell you whether a post is ready for publication, has errors, or is still a work in progress.

The dashboard also includes:

A stats bar (archive posts, vault notes, track counts, drafts, errors, ready posts)
Full‑text search
Filter buttons for tracks, drafts, recent edits, errors
Sort options (series order, newest first, oldest first, title, errors first, drafts first)

Live Frontmatter Validation

Missing a required field like title, description, or track can cause your Astro build to fail silently. isHistory CMS validates every post against your content schema in real time, directly inside Obsidian.

The validation engine checks for:

Missing required fields
Badly formatted dates
Tags that aren't YAML lists
Series fields with missing partners
Track mismatches
Draft/published conflicts

Errors and warnings appear on dashboard cards and in the sidebar validator as you type. What used to be a build‑time surprise becomes an in‑your‑face fix‑it‑now prompt while you're still editing.

Pre‑flight: Mark Posts Ready for Deployment

The Pre‑flight button is the heart of the publishing workflow. When you click Pre‑flight on a post, the plugin:

Sets draft: false in frontmatter
Adds a published timestamp (and today's date if none is set)

This signals your Astro site that the post is ready to go live on the next build. You can also Pre‑flight multiple posts at once through the bulk operation modal.

Important: Pre‑flight marks the post as ready, but it does not deploy it. Deployment requires a separate Git sync step (see Getting Started).

Mobile‑First Design

isHistory CMS is built with mobile support from the ground up. The manifest declares isDesktopOnly: false, and every UI component is tested on the Obsidian mobile app. The dashboard grid adapts to smaller screens, the sidebar view works in the mobile drawer, and the new post creation flow is fully touch‑friendly.

The Technical Journey: From Idea to Official Plugin

Getting a plugin into the Obsidian Community Plugin directory is a rigorous process. Here are the key lessons from my review journey.

Eliminating XSS Vectors

The review team flagged three instances of innerHTML in my initial code. I replaced every one with Obsidian's native createEl API, which constructs DOM elements programmatically and automatically escapes dangerous content.

Taming Asynchronous Chaos

Obsidian plugins interact with the vault file system through event listeners. My solution was a centralized debouncing framework that queues file paths and processes them on a schedule, eliminating race conditions and UI freezes.

Honest UX: Pre‑flight, Not Publish

I originally called the button "Publish." But the plugin only modifies local frontmatter — actual deployment requires Git. Renaming it to Pre‑flight sets accurate expectations: the plane is ready for takeoff, but the pilot (you) still needs to push the throttles (Git sync).

The CSS Specificity Lesson

The review's CSS lint caught five uses of !important. I replaced them with higher‑specificity selectors (e.g., .cms-card.cms-card-track-A instead of .cms-card-track-A with !important).

Artifact Attestations and Build Verification

I set up a GitHub Actions workflow that runs on every tag push, executes a build verification script, generates attestations for main.js and styles.css, and creates the release automatically. The build script checks for forbidden patterns like innerHTML and console.log, and verifies no !important remains in the CSS.

The Broader Ecosystem

The idea of using Obsidian as a CMS for Astro isn't new. Several tools have explored this space:

Tool	Focus
Vault CMS	Open‑source headless CMS with auto‑detection of routes and preconfigured workspace
Astro Composer	Automates post creation, slug generation, and link conversion
Bases CMS	Card‑based views and bulk operations for Obsidian's core Bases plugin

Where does isHistory CMS fit? While Vault CMS emphasises automation and a complete publishing platform, isHistory CMS is built for writers who need rigorous frontmatter validation, track‑based organisation, and a clean editorial interface inside Obsidian. It's designed for the isHistory AI history project but works with any Astro site that uses Content Collections.

Current stats: 25 downloads, four releases, recent v1.6.0 update. The plugin has not yet been manually reviewed by Obsidian staff, but it's available in the community directory.

Getting Started with isHistory CMS

Installation

Open Obsidian -> Settings -> Community Plugins -> Browse
Search for isHistory CMS
Install and enable the plugin
A new ribbon icon will appear — click it to open the dashboard

Configuration

The plugin looks for content inside src/content/blog (archive path) and src/content/vault by default. If your Astro project is structured differently, change these paths in Settings -> isHistory CMS.

No external server, no API keys, no cloud dependency. Your data stays in your vault, on your machine, under your control.

Deployment Pipeline

Pre‑flighting a post marks it as ready, but it doesn't push it live. To deploy:

Install Obsidian Git
Configure it to auto‑commit and push on an interval (e.g., every 5 minutes)
Your Astro site's CI/CD (Vercel, Netlify, Cloudflare Pages, etc.) detects the push and rebuilds automatically

Full pipeline: Write -> Pre‑flight -> Git sync -> Auto‑deploy

If you click Pre‑flight and your site doesn't update, the first place to check is your Git sync — the plugin's FAQ covers this exact scenario.

Why I Built This and What Comes Next

I built isHistory CMS because Obsidian is where I think and write. It should also be where I manage my content. Now it finally is.

The Obsidian plugin review process pushed the code toward a higher standard of security, usability, and maintainability. The result is a plugin I use every day to run my own site — and one that has already been downloaded 25 times since its recent release.

Roadmap

Git integration – embed Git operations directly so Pre‑flight can optionally commit and push without a separate plugin
Schema auto‑detection – read Astro content config files to eliminate manual path configuration
Media management view – bring image and asset management into the same dashboard

Try isHistory CMS

If you're running an Astro site — especially a content‑heavy one with complex frontmatter validation needs — give isHistory CMS a try.

Install isHistory CMS from Obsidian Community Plugins

Free and open source (MIT licensed)
Available now in the Obsidian Community Plugin directory

Write in Obsidian. Validate in real time. Pre‑flight with confidence. Deploy with Git. Your notes deserve a better CMS, and now they have one.

FAQ

Q: Does isHistory CMS work with any Astro site? A: Yes — it works with any Astro project that uses Content Collections. The default paths are src/content/blog and src/content/vault, but you can configure them in settings.

Q: Does the plugin deploy my site? A: No. Pre‑flight only modifies local frontmatter (sets draft: false and adds timestamps). Deployment requires a Git sync (e.g., Obsidian Git) and your hosting platform's auto‑deploy.

Q: Is my data sent to any server? A: No. Everything stays in your local Obsidian vault. No external APIs, no telemetry, no cloud dependencies.

Q: Is it really mobile‑friendly? A: Yes. The plugin is tested on the Obsidian mobile app and adapts to smaller screens.

Q: How is this different from Vault CMS? A: Vault CMS focuses on automation and a complete publishing platform. isHistory CMS focuses on rigorous validation, track‑based organisation, and a clean editorial interface — ideal for writers managing complex frontmatter.

Linked References

isHistory CMS