Microkernel (Plugin) Architecture

The big idea

A smartphone ships with a small, stable operating system. Everything else (maps, games, banking, a flashlight) comes from apps you install. The phone maker doesn't rebuild the OS for each new app; apps plug in through a published contract (the app store rules and APIs).

Microkernel architecture (also called plug-in architecture) works the same way: a minimal core system plus independent plug-in modules that extend it.

Microkernel: a small core with plug-ins attached through a contract

Where you've already seen it

The parts

Building one: a tiny Markdown processor

1. Define the contract

// core/contract.ts: the ONLY thing plug-ins import from the core
export interface MarkdownPlugin {
  name: string;
  version: string;
  /** Transform raw markdown before parsing (optional hook) */
  beforeParse?(markdown: string): string;
  /** Transform the rendered HTML (optional hook) */
  afterRender?(html: string): string;
}

2. The core: registry + lifecycle

// core/processor.ts
export class MarkdownProcessor {
  private plugins: MarkdownPlugin[] = [];

  use(plugin: MarkdownPlugin): this {
    if (this.plugins.some((p) => p.name === plugin.name)) throw new Error(`Plugin ${plugin.name} already registered`);
    this.plugins.push(plugin);
    return this;
  }

  render(markdown: string): string {
    const source = this.plugins.reduce((text, p) => p.beforeParse?.(text) ?? text, markdown);
    const html = basicMarkdownToHtml(source);                     // the core's own small job
    return this.plugins.reduce((out, p) => p.afterRender?.(out) ?? out, html);
  }
}

3. Plug-ins: independent features

// plugins/emoji.ts
export const emojiPlugin: MarkdownPlugin = {
  name: "emoji",
  version: "1.0.0",
  beforeParse: (md) => md.replaceAll(":rocket:", "🚀").replaceAll(":tada:", "🎉"),
};

// plugins/external-links.ts
export const externalLinksPlugin: MarkdownPlugin = {
  name: "external-links",
  version: "1.2.0",
  afterRender: (html) => html.replace(/<a href="http/g, '<a target="_blank" rel="noreferrer" href="http'),
};

// app.ts
const processor = new MarkdownProcessor().use(emojiPlugin).use(externalLinksPlugin);
processor.render("Launch day :rocket: [docs](https://example.com)");

The Open/Closed Principle at architecture scale: the core is closed for modification, open for extension.

Designing the contract well

// Defensive loading: a broken plug-in is disabled, not fatal
for (const plugin of discovered) {
  try {
    assertCompatible(plugin.version, CONTRACT_VERSION);
    processor.use(plugin);
  } catch (error) {
    logger.warn({ plugin: plugin.name, error }, "Plugin disabled");
  }
}

Plug-in discovery

Trade-offs

When to use it

✅ Products that need customisation or third-party extensions (IDEs, CMSs, build tools), rules that vary by customer, country or product line, and features that should be switched on and off independently.

❌ Apps without a clear, stable core or without real variation. A plug-in system nobody plugs into is YAGNI.

Key takeaways

• Microkernel = a small, stable core plus independent plug-ins connected through a contract.
• VS Code, browsers, Webpack, ESLint and WordPress are all built this way.
• Keep the contract small, versioned and stable; plug-ins depend only on it.
• Isolate plug-in failures (and, for third parties, security).
• Use it when extensibility and variation are real requirements.