diff --git a/src/lib/diff.ts b/src/lib/diff.ts
new file mode 100644
index 0000000..abc9043
--- /dev/null
+++ b/src/lib/diff.ts
@@ -0,0 +1,18 @@
+import DiffMatchPatch from "diff-match-patch";
+
+const dmp = new DiffMatchPatch();
+
+export function createDiff(oldText: string, newText: string): string {
+	const patches = dmp.patch_make(oldText, newText);
+	return dmp.patch_toText(patches);
+}
+
+export function applyDiff(text: string, patchText: string): string {
+	const patches = dmp.patch_fromText(patchText);
+	const [result, applied] = dmp.patch_apply(patches, text);
+	const failed = applied.filter((ok) => !ok);
+	if (failed.length > 0) {
+		throw new Error(`Failed to apply ${failed.length} patch(es)`);
+	}
+	return result;
+}
diff --git a/src/lib/markdown.ts b/src/lib/markdown.ts
new file mode 100644
index 0000000..9ce505f
--- /dev/null
+++ b/src/lib/markdown.ts
@@ -0,0 +1,89 @@
+import MarkdownIt from "markdown-it";
+import type StateInline from "markdown-it/lib/rules_inline/state_inline.mjs";
+import { type VizPluginEnv, vizPlugin } from "./viz/plugin.ts";
+
+export interface RenderResult {
+	html: string;
+	hasViz: boolean;
+}
+
+export interface MarkdownEnv extends VizPluginEnv {
+	wikiSlug?: string;
+}
+
+const md = new MarkdownIt({ html: false, linkify: true });
+
+// Wikilink plugin: transforms [[slug]] and [[slug|label]] into links
+function wikilinkPlugin(mdi: MarkdownIt): void {
+	mdi.inline.ruler.push("wikilink", (state: StateInline, silent: boolean) => {
+		const src = state.src;
+		const pos = state.pos;
+
+		if (src[pos] !== "[" || src[pos + 1] !== "[") return false;
+
+		const closeIdx = src.indexOf("]]", pos + 2);
+		if (closeIdx === -1) return false;
+
+		if (!silent) {
+			const content = src.slice(pos + 2, closeIdx);
+			let slug: string;
+			let label: string;
+			if (content.includes("|")) {
+				const parts = content.split("|");
+				slug = parts[0] ?? content;
+				label = parts.slice(1).join("|");
+			} else {
+				slug = content;
+				label = content;
+			}
+
+			const env = state.env as MarkdownEnv;
+			const wikiSlug = env.wikiSlug;
+			const href = wikiSlug ? `/wiki/${wikiSlug}/${slug.trim()}` : slug.trim();
+
+			const token = state.push("html_inline", "", 0);
+			token.content = `<a href="${href}" class="wikilink">${label.trim()}</a>`;
+		}
+
+		state.pos = closeIdx + 2;
+		return true;
+	});
+}
+
+md.use(wikilinkPlugin);
+md.use(vizPlugin);
+
+export function renderMarkdown(
+	source: string,
+	wikiSlug?: string,
+): RenderResult {
+	const env: MarkdownEnv = { wikiSlug };
+	const html = md.render(source, env);
+	return { html, hasViz: env.hasViz === true };
+}
+
+/**
+ * Extract unique wikilink target slugs from markdown content.
+ * Matches [[slug]] and [[slug|label]], returns deduplicated trimmed slugs.
+ */
+export function extractWikilinks(content: string): string[] {
+	const seen = new Set<string>();
+	let pos = 0;
+	while (pos < content.length) {
+		if (content[pos] === "[" && content[pos + 1] === "[") {
+			const closeIdx = content.indexOf("]]", pos + 2);
+			if (closeIdx === -1) break;
+			const inner = content.slice(pos + 2, closeIdx);
+			const slug = (inner.includes("|") ? inner.split("|")[0] : inner)?.trim();
+			if (slug) {
+				seen.add(slug);
+			}
+			pos = closeIdx + 2;
+		} else {
+			pos++;
+		}
+	}
+	return [...seen];
+}
+
+export { md };
diff --git a/src/lib/slug.ts b/src/lib/slug.ts
new file mode 100644
index 0000000..220c83d
--- /dev/null
+++ b/src/lib/slug.ts
@@ -0,0 +1,7 @@
+export { default as slugify } from "@sindresorhus/slugify";
+
+const SLUG_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+
+export function isValidSlug(slug: string): boolean {
+	return SLUG_RE.test(slug) && slug.length >= 1 && slug.length <= 128;
+}
diff --git a/tests/lib/diff.test.ts b/tests/lib/diff.test.ts
new file mode 100644
index 0000000..b9e1a69
--- /dev/null
+++ b/tests/lib/diff.test.ts
@@ -0,0 +1,63 @@
+import { describe, expect, test } from "bun:test";
+import { applyDiff, createDiff } from "../../src/lib/diff.ts";
+
+describe("createDiff and applyDiff", () => {
+	test("roundtrips a simple edit", () => {
+		const oldText = "Hello world";
+		const newText = "Hello brave new world";
+		const diff = createDiff(oldText, newText);
+		expect(applyDiff(oldText, diff)).toBe(newText);
+	});
+
+	test("handles first revision (diff from empty)", () => {
+		const content = "# My First Note\n\nSome content here.";
+		const diff = createDiff("", content);
+		expect(applyDiff("", diff)).toBe(content);
+	});
+
+	test("handles deletion", () => {
+		const oldText = "line one\nline two\nline three";
+		const newText = "line one\nline three";
+		const diff = createDiff(oldText, newText);
+		expect(applyDiff(oldText, diff)).toBe(newText);
+	});
+
+	test("handles no change", () => {
+		const text = "unchanged content";
+		const diff = createDiff(text, text);
+		expect(applyDiff(text, diff)).toBe(text);
+	});
+
+	test("handles multiline markdown", () => {
+		const oldText = "# Title\n\nParagraph one.\n\n## Section\n\nParagraph two.";
+		const newText =
+			"# Title\n\nParagraph one, edited.\n\n## Section\n\nParagraph two.\n\n## New Section\n\nNew content.";
+		const diff = createDiff(oldText, newText);
+		expect(applyDiff(oldText, diff)).toBe(newText);
+	});
+
+	test("chains multiple diffs", () => {
+		const v1 = "";
+		const v2 = "Hello";
+		const v3 = "Hello world";
+		const v4 = "Hello brave world";
+
+		const diff1 = createDiff(v1, v2);
+		const diff2 = createDiff(v2, v3);
+		const diff3 = createDiff(v3, v4);
+
+		let current = v1;
+		current = applyDiff(current, diff1);
+		expect(current).toBe(v2);
+		current = applyDiff(current, diff2);
+		expect(current).toBe(v3);
+		current = applyDiff(current, diff3);
+		expect(current).toBe(v4);
+	});
+
+	test("diff output is a string", () => {
+		const diff = createDiff("a", "b");
+		expect(typeof diff).toBe("string");
+		expect(diff.length).toBeGreaterThan(0);
+	});
+});
diff --git a/tests/lib/markdown.test.ts b/tests/lib/markdown.test.ts
new file mode 100644
index 0000000..07802b9
--- /dev/null
+++ b/tests/lib/markdown.test.ts
@@ -0,0 +1,156 @@
+import { describe, expect, test } from "bun:test";
+import { extractWikilinks, renderMarkdown } from "../../src/lib/markdown.ts";
+
+describe("renderMarkdown", () => {
+	test("renders basic markdown", () => {
+		const { html } = renderMarkdown("# Hello\n\nWorld");
+		expect(html).toContain("<h1>Hello</h1>");
+		expect(html).toContain("<p>World</p>");
+	});
+
+	test("renders bold and italic", () => {
+		const { html } = renderMarkdown("**bold** and *italic*");
+		expect(html).toContain("<strong>bold</strong>");
+		expect(html).toContain("<em>italic</em>");
+	});
+
+	test("renders code blocks", () => {
+		const { html } = renderMarkdown("```js\nconsole.log('hi');\n```");
+		expect(html).toContain("<code");
+		expect(html).toContain("console.log");
+	});
+
+	test("renders inline code", () => {
+		const { html } = renderMarkdown("use `const` here");
+		expect(html).toContain("<code>const</code>");
+	});
+
+	test("renders links", () => {
+		const { html } = renderMarkdown("[click](https://example.com)");
+		expect(html).toContain('href="https://example.com"');
+		expect(html).toContain("click");
+	});
+
+	test("does not render raw HTML", () => {
+		const { html } = renderMarkdown('<script>alert("xss")</script>');
+		expect(html).not.toContain("<script>");
+	});
+
+	test("returns hasViz false for normal markdown", () => {
+		const { hasViz } = renderMarkdown("# Normal content");
+		expect(hasViz).toBe(false);
+	});
+
+	test("returns hasViz true when viz block is present", () => {
+		const { hasViz } = renderMarkdown(
+			'```viz-graph\n{"nodes":[{"id":"a"}],"links":[]}\n```',
+		);
+		expect(hasViz).toBe(true);
+	});
+});
+
+describe("wikilinks", () => {
+	const WIKI = "test-wiki";
+
+	test("renders [[slug]] as a link with wiki prefix", () => {
+		const { html } = renderMarkdown("see [[my-page]]", WIKI);
+		expect(html).toContain('href="/wiki/test-wiki/my-page"');
+		expect(html).toContain("my-page");
+		expect(html).toContain('class="wikilink"');
+	});
+
+	test("renders [[slug|label]] with custom label", () => {
+		const { html } = renderMarkdown("see [[my-page|My Page Title]]", WIKI);
+		expect(html).toContain('href="/wiki/test-wiki/my-page"');
+		expect(html).toContain("My Page Title");
+	});
+
+	test("handles multiple wikilinks in one line", () => {
+		const { html } = renderMarkdown("[[page-a]] and [[page-b]]", WIKI);
+		expect(html).toContain('href="/wiki/test-wiki/page-a"');
+		expect(html).toContain('href="/wiki/test-wiki/page-b"');
+	});
+
+	test("handles wikilink with pipe in label", () => {
+		const { html } = renderMarkdown("[[slug|label with | pipe]]", WIKI);
+		expect(html).toContain('href="/wiki/test-wiki/slug"');
+		expect(html).toContain("label with | pipe");
+	});
+
+	test("does not match unclosed brackets", () => {
+		const { html } = renderMarkdown("[[unclosed", WIKI);
+		expect(html).not.toContain("wikilink");
+		expect(html).toContain("[[unclosed");
+	});
+
+	test("trims whitespace in slug and label", () => {
+		const { html } = renderMarkdown("[[ my-page | My Page ]]", WIKI);
+		expect(html).toContain('href="/wiki/test-wiki/my-page"');
+		expect(html).toContain("My Page");
+	});
+
+	test("works alongside normal markdown", () => {
+		const { html } = renderMarkdown("**bold** and [[link]]", WIKI);
+		expect(html).toContain("<strong>bold</strong>");
+		expect(html).toContain('class="wikilink"');
+	});
+
+	test("falls back to bare slug when no wikiSlug provided", () => {
+		const { html } = renderMarkdown("see [[my-page]]");
+		expect(html).toContain('href="my-page"');
+	});
+});
+
+describe("extractWikilinks", () => {
+	test("returns empty array for content with no wikilinks", () => {
+		expect(extractWikilinks("no links here")).toEqual([]);
+	});
+
+	test("returns empty array for empty string", () => {
+		expect(extractWikilinks("")).toEqual([]);
+	});
+
+	test("extracts a single [[slug]]", () => {
+		expect(extractWikilinks("see [[my-page]]")).toEqual(["my-page"]);
+	});
+
+	test("extracts slug from [[slug|label]]", () => {
+		expect(extractWikilinks("see [[my-page|My Page]]")).toEqual(["my-page"]);
+	});
+
+	test("extracts multiple wikilinks", () => {
+		const result = extractWikilinks("[[page-a]] and [[page-b]]");
+		expect(result).toEqual(["page-a", "page-b"]);
+	});
+
+	test("deduplicates repeated slugs", () => {
+		const result = extractWikilinks("[[foo]] then [[foo]] again");
+		expect(result).toEqual(["foo"]);
+	});
+
+	test("trims whitespace from slugs", () => {
+		expect(extractWikilinks("[[ spaced ]]")).toEqual(["spaced"]);
+	});
+
+	test("trims whitespace from piped slugs", () => {
+		expect(extractWikilinks("[[ spaced | Label ]]")).toEqual(["spaced"]);
+	});
+
+	test("ignores unclosed brackets", () => {
+		expect(extractWikilinks("[[unclosed")).toEqual([]);
+	});
+
+	test("handles wikilinks across multiple lines", () => {
+		const result = extractWikilinks("line1 [[a]]\nline2 [[b]]");
+		expect(result).toEqual(["a", "b"]);
+	});
+
+	test("handles pipe in label (takes first part as slug)", () => {
+		const result = extractWikilinks("[[slug|label with | pipe]]");
+		expect(result).toEqual(["slug"]);
+	});
+
+	test("skips empty slug between brackets", () => {
+		expect(extractWikilinks("[[]]")).toEqual([]);
+	});
+});
diff --git a/tests/lib/slug.test.ts b/tests/lib/slug.test.ts
new file mode 100644
index 0000000..fde8b9e
--- /dev/null
+++ b/tests/lib/slug.test.ts
@@ -0,0 +1,46 @@
+import { describe, expect, test } from "bun:test";
+import { isValidSlug } from "../../src/lib/slug.ts";
+
+describe("isValidSlug", () => {
+	test("accepts simple slugs", () => {
+		expect(isValidSlug("hello")).toBe(true);
+		expect(isValidSlug("hello-world")).toBe(true);
+		expect(isValidSlug("a")).toBe(true);
+	});
+
+	test("accepts slugs with numbers", () => {
+		expect(isValidSlug("page1")).toBe(true);
+		expect(isValidSlug("123")).toBe(true);
+		expect(isValidSlug("v2-release")).toBe(true);
+	});
+
+	test("rejects uppercase", () => {
+		expect(isValidSlug("Hello")).toBe(false);
+	});
+
+	test("rejects spaces", () => {
+		expect(isValidSlug("hello world")).toBe(false);
+	});
+
+	test("rejects underscores", () => {
+		expect(isValidSlug("hello_world")).toBe(false);
+	});
+
+	test("rejects leading or trailing hyphens", () => {
+		expect(isValidSlug("-hello")).toBe(false);
+		expect(isValidSlug("hello-")).toBe(false);
+	});
+
+	test("rejects consecutive hyphens", () => {
+		expect(isValidSlug("hello--world")).toBe(false);
+	});
+
+	test("rejects empty string", () => {
+		expect(isValidSlug("")).toBe(false);
+	});
+
+	test("rejects slugs over 128 characters", () => {
+		expect(isValidSlug("a".repeat(128))).toBe(true);
+		expect(isValidSlug("a".repeat(129))).toBe(false);
+	});
+});