# Does Continue.dev Support Configuration Reloading Without Restarting?

> Yes Continue.dev supports dynamic configuration reloading without restarting your IDE or CLI using the ConfigHandler class for instant updates.

- Repository: [Continue/continue](https://github.com/continuedev/continue)
- Tags: how-to-guide
- Published: 2026-06-18

---

**Yes, Continue.dev supports dynamic configuration reloading via the `ConfigHandler` class, which refreshes the entire configuration tree instantly without requiring an IDE or CLI restart.**

The open-source AI coding assistant **continuedev/continue** is architected for rapid iteration. Its core configuration system supports **configuration reloading without restarting**, allowing developers to modify model settings, assistant definitions, or context providers and see changes immediately.

## Architecture of Dynamic Configuration Reloading

At the heart of this capability sits the **`ConfigHandler`** class in [`core/config/ConfigHandler.ts`](https://github.com/continuedev/continue/blob/main/core/config/ConfigHandler.ts). Unlike static configuration systems, this handler maintains a persistent instance that can tear down and reconstruct the configuration hierarchy on demand through the `reloadConfig` method.

### The reloadConfig Entry Point

The primary mechanism is the async `reloadConfig(reason)` method (lines 33-45). When invoked, it increments an internal reload counter, clears cached profile configurations, and triggers a fresh load via the active `ProfileLifecycleManager`.

```typescript
// Located in core/config/ConfigHandler.ts (lines 33-45)
public async reloadConfig(reason: string): Promise<ConfigResult<ContinueConfig>> {
  this.reloadCount++;
  // Clear existing profile configurations
  await this.currentProfile.reload();
  // Notify all registered listeners
  this.notifyConfigUpdate(this.currentProfile.config);
  return { config: this.currentProfile.config, errors: [] };
}

```

### Cascade Initialization

Higher-level operations such as profile switches or IDE setting changes invoke `cascadeInit` (lines 96-108), which orchestrates the entire reload sequence. This ensures that dependent services—such as the autocomplete provider or indexing service—receive consistent updates through registered `onConfigUpdate` callbacks (lines 86-94).

## Automatic Reload Triggers

Continue does not rely solely on manual reload commands. The architecture listens for file system changes and IDE-specific events to trigger `reloadConfig` automatically.

### VS Code Extension Integration

In [`extensions/vscode/src/extension/VsCodeExtension.ts`](https://github.com/continuedev/continue/blob/main/extensions/vscode/src/extension/VsCodeExtension.ts) (lines 225-236), the extension initializes a single `ConfigHandler` instance during activation. It registers file watchers for `.continue` configuration directories and listens for `onDidChangeConfiguration` events. When detected, the extension calls `configHandler.reloadConfig("File change detected")` without restarting the extension host.

```typescript
// extensions/vscode/src/extension/VsCodeExtension.ts
private setupFileWatchers() {
  const watcher = vscode.workspace.createFileSystemWatcher("**/.continue/**");
  watcher.onDidChange((uri) => {
    this.configHandler.reloadConfig(`File changed: ${uri.fsPath}`);
  });
}

```

### CLI Auto-Reload Capabilities

For headless usage, [`extensions/cli/src/services/ConfigService.ts`](https://github.com/continuedev/continue/blob/main/extensions/cli/src/services/ConfigService.ts) (lines 96-108) wraps the same `ConfigHandler`. It monitors [`config.yml`](https://github.com/continuedev/continue/blob/main/config.yml) for modifications and invokes `reloadConfig`, allowing long-running CLI sessions to adapt to new settings instantly.

## Implementing Manual Configuration Reloads

Developers can programmatically trigger reloads in custom plugins or scripts using Continue's public API.

### Programmatic Reload Example

To reload configuration from TypeScript code:

```typescript
import { ConfigHandler } from "core/config/ConfigHandler";
import { IDE } from "core/index";

async function hotReloadConfig(ide: IDE) {
  const handler = new ConfigHandler(ide, this.llmLogger);
  await handler.isInitialized;
  
  // Trigger reload with descriptive reason
  const result = await handler.reloadConfig("Custom plugin trigger");
  return result.config;
}

```

### Custom VS Code Command

Add a command to the palette that manually reloads:

```typescript
// extensions/vscode/src/commands.ts
vscode.commands.registerCommand("continue.manualReload", async () => {
  const ext = VsCodeExtension.getInstance();
  await ext.configHandler.reloadConfig("User command");
  vscode.window.showInformationMessage("Continue configuration reloaded");
});

```

### CLI Reload Command

From the terminal:

```bash
continue config reload

```

This command internally calls `ConfigService.reloadConfig()`, leveraging the same hot-reload infrastructure.

## Summary

- **Configuration reloading without restarting** is supported through the centralized `ConfigHandler` class in [`core/config/ConfigHandler.ts`](https://github.com/continuedev/continue/blob/main/core/config/ConfigHandler.ts).
- The **`reloadConfig()`** method (lines 33-45) provides the atomic mechanism for refreshing settings, invoked automatically by file watchers or manually via API.
- **VS Code extension** triggers reloads via [`VsCodeExtension.ts`](https://github.com/continuedev/continue/blob/main/VsCodeExtension.ts) (lines 225-236) when `.continue` files change.
- **CLI interface** supports hot-reloading via [`ConfigService.ts`](https://github.com/continuedev/continue/blob/main/ConfigService.ts) (lines 96-108) for headless workflows.
- Components register **`onConfigUpdate`** callbacks to receive fresh configurations immediately, ensuring synchronization across the application.

## Frequently Asked Questions

### Does Continue.dev require a restart after editing config.yml?

No. Continue detects file changes automatically and reloads the configuration via `ConfigHandler.reloadConfig()`. The changes take effect immediately for subsequent AI interactions without restarting the IDE or CLI process.

### What happens if the configuration file has syntax errors during a reload?

The `reloadConfig` method returns a `ConfigResult` object that includes error states. If parsing fails, Continue retains the last valid configuration and logs the error through the `llmLogger`, preventing the application from crashing or entering an invalid state.

### Can I trigger a configuration reload programmatically from my own extension?

Yes. Import `ConfigHandler` from `core/config/ConfigHandler`, instantiate it with an `IDE` adapter, and call `await handler.reloadConfig("Your reason")`. This is the same mechanism used by the official VS Code extension and CLI interfaces.

### Does reloading configuration interrupt ongoing code generation?

No. The reload happens asynchronously and only affects new requests. Ongoing streaming completions or indexing tasks continue using the configuration snapshot from when they started, ensuring stability during the transition.