Microkernel Architecture: Building Extensible Plugin-Based Systems Like VS Code

Microkernel System:

+-----------------------------------------------------+
|                   CORE SYSTEM                        |
|  +---------------------------------------------+   |
|  |  Minimal, stable, infrequently changed       |   |
|  |  "¢ Plugin Registry (discover + load plugins) |   |
|  |  "¢ Lifecycle Manager (start/stop)            |   |
|  |  "¢ Hook System (event bus / extension points)|   |
|  |  "¢ Core Services (logging, config, auth)     |   |
|  +----------------------------------------------+   |
+------------------------------------------------------+
         ←• Plugin Contract (stable interface)
+----------+  +----------+  +----------+  +----------+
| Plugin A |  | Plugin B |  | Plugin C |  | Plugin D |
|(Git)     |  |(Linting) |  |(Theme)   |  |(Debugger)|
+-----------+  +-----------+  +-----------+  +-----------+
Independently versioned, developed, deployed

// Core: Plugin Registry - the heart of the system
interface PluginManifest {
    id: string;
    version: string;
    name: string;
    description: string;
    main: string;          // Entry point file
    hooks: string[];       // Which hooks this plugin subscribes to
    permissions: string[]; // What APIs this plugin can access
}

class PluginRegistry {
    private plugins = new Map<string, LoadedPlugin>();
    private hooks = new Map<string, Array<HookHandler>>();
    
    async register(manifest: PluginManifest, pluginInstance: Plugin): Promise<void> {
        // Validate plugin manifest schema:
        await this.validateManifest(manifest);
        
        // Register all hook subscriptions:
        for (const hookName of manifest.hooks) {
            if (!this.hooks.has(hookName)) {
                this.hooks.set(hookName, []);
            }
            this.hooks.get(hookName)!.push({
                pluginId: manifest.id,
                handler: pluginInstance.onHook.bind(pluginInstance),
            });
        }
        
        this.plugins.set(manifest.id, { manifest, instance: pluginInstance });
        console.log(`[Registry] Registered plugin: ${manifest.id}@${manifest.version}`);
    }
    
    async trigger(hookName: string, context: HookContext): Promise<HookContext> {
        const handlers = this.hooks.get(hookName) || [];
        let currentContext = context;
        
        for (const { pluginId, handler } of handlers) {
            try {
                currentContext = await handler(currentContext);
            } catch (error) {
                // ✅ Plugin failure is isolated - core and other plugins continue:
                console.error(`[Registry] Plugin ${pluginId} failed on hook ${hookName}:`, error);
                // Optionally emit a diagnostic event for plugin health monitoring
            }
        }
        return currentContext;
    }
    
    unregister(pluginId: string): void {
        // Remove all hook handlers for this plugin:
        for (const handlers of this.hooks.values()) {
            const idx = handlers.findIndex(h => h.pluginId === pluginId);
            if (idx !== -1) handlers.splice(idx, 1);
        }
        this.plugins.delete(pluginId);
    }
}

// The Plugin Contract (stable API - breaking changes require semver major bump):
interface Plugin {
    // Lifecycle hooks:
    onActivate(context: PluginActivationContext): Promise<void>;
    onDeactivate(): Promise<void>;
    
    // Hook handler:
    onHook(hookName: string, context: HookContext): Promise<HookContext>;
}

interface PluginActivationContext {
    // Services the core provides to plugins:
    readonly logger: Logger;
    readonly config: ConfigService;
    readonly eventBus: EventBus;
    readonly registerCommand: (id: string, handler: CommandHandler) => void;
    readonly registerView: (id: string, component: ViewComponent) => void;
    // ❌ No direct database access - plugins use services, not raw DB
    // ❌ No filesystem access - plugins use the sandbox file API
}

// Example plugin implementation:
class GitPlugin implements Plugin {
    private disposables: Disposable[] = [];
    
    async onActivate(ctx: PluginActivationContext): Promise<void> {
        ctx.logger.info('Git plugin activated');
        
        // Register commands (core routes these):
        this.disposables.push(
            ctx.registerCommand('git.commit', this.handleCommit.bind(this)),
            ctx.registerCommand('git.push', this.handlePush.bind(this)),
        );
        
        // Subscribe to file save events via event bus:
        this.disposables.push(
            ctx.eventBus.on('file.saved', this.onFileSaved.bind(this))
        );
    }
    
    async onDeactivate(): Promise<void> {
        // Clean up all subscriptions and resources:
        this.disposables.forEach(d => d.dispose());
        this.disposables = [];
    }
    
    async onHook(hookName: string, context: HookContext): Promise<HookContext> {
        if (hookName === 'editor.decorations') {
            // Add git blame annotations to the context:
            return { ...context, decorations: [...context.decorations, ...this.getBlameDecorations()]}; 
        }
        return context;
    }
}

VS Code Process Architecture:

+-----------------------------+     IPC (JSON-RPC)    +---------------------+
|   Main Process (Electron)   | ←-------------------- |  Extension Host     |
|   "¢ Window management       |                        |  "¢ All extensions   |
|   "¢ File system access      | ----------------------->|  "¢ Extension API    |
|   "¢ UI rendering            |     Events & calls     |  "¢ Language servers |
|   "¢ Core editor features    |                        |                     |
+------------------------------+                        +----------------------+

Extension lifecycle:
1. Extension declares hooks in package.json:
   "activationEvents": ["onLanguage:python"]
2. Main process sees a .py file opened -> activates Python extension in Extension Host
3. Python extension calls vscode.languages.registerCompletionProvider()
4. Main process receives registration over IPC - proxies completions back
5. User sees IntelliSense - powered by extension, rendered by core