Code Insight Stopped Working in RAD Studio? A Diagnostic Guide for Delphi and C++Builder

When Code Insight dies in RAD Studio — no completion dropdown on Ctrl+Space, no parameter hints, no red Error Insight squiggles — the cause is almost never the language server itself. It's usually a corrupted cache, a broken library path, a third-party IDE package, or one malformed unit silently blocking the parser. This guide walks through the conditions, ordered checks, and fixes, so you can isolate the failure instead of reinstalling the IDE.

Recognizing the failure mode

Code Insight failures fall into a few recognizable patterns, and the pattern is your first diagnostic clue:

• Everything fails, in every project. No completion, no hints, no Error Insight anywhere. Suspect the LSP server process or an IDE-wide package conflict.
• One project fails, a new project works. Suspect the project's .identcache, the project file (.dproj / .cbproj), or project-specific search paths.
• Insight works in some units but not others. Suspect a syntax error early in the unit or in a unit on the uses chain — the parser gives up past the first blocking error.
• Insight degrades over a long session. Works after restart, gets slower and then stops. Suspect memory pressure in the 32-bit IDE or an LSP memory leak.

Cause and diagnostic table

Symptom	Likely cause	Quick check
Insight dead in all projects	DelphiLSP.exe / cppLSP crashed or not running	Task Manager: is the process present? LSP Output pane shows errors?
One project dead, new project fine	Corrupted .identcache or .dproj	Delete .identcache, restart IDE
Completion works, but wrong/missing symbols	Invalid or duplicate Library Path entries	Tools → Options → Language → Library Path
Insight dead after installing an add-in	IDE expert conflict (GExperts, CnPack, Parnassus, etc.)	Launch with bds.exe -p
Slow degradation over hours	32-bit IDE memory ceiling (~1.8 GB) or LSP leak	Watch bds.exe and DelphiLSP.exe memory in Task Manager
Insight dies partway through a unit	Syntax error blocking the parser	Fix the first reported error; check units in the uses clause

Ordered checks, fastest first

1. Baseline: does a new project work?

Create a new blank VCL application, add a button, and in the click handler type TButton.Create(. The parameter hint should appear within about half a second. If it does, the IDE and LSP are fine and the problem is project-scoped — skip to check 3. If it doesn't, continue here.

2. Check the LSP server process

RAD Studio's Code Insight runs through a Language Server Protocol process: DelphiLSP.exe for Delphi, the C++ equivalent for C++Builder. Open Task Manager and look for it while the IDE is running. If it's missing or you suspect a crash, kill any stale instance and restart the IDE — the server restarts with it.

For real evidence, open the LSP Output pane via View → Diagnostic Tools → LSP Server Output. A healthy server logs a startup line and stays quiet as you type. Crash, timeout, or initialization-failed lines in red confirm the server is your problem. Note that the in-IDE LSP restart button only appears when the server is actually running; if you don't see it, use Task Manager.

3. Delete the project's .identcache

The .identcache folder (next to your project file) holds the parsed symbol index. If it corrupts, Insight fails for that project while everything else works. Close the IDE, delete the folder, and reopen the project.

Cost: this forces a full re-index. On a large project the first reopen can take several minutes — watch the Output window for the indexing completion message before judging whether it worked. Don't interrupt it.

4. Audit the Library Path

Go to Tools → Options → Language → Library Path (and the project-level search path in Project → Options). Look for entries pointing to folders that no longer exist, duplicates, and paths from older RAD Studio versions left behind after an upgrade. The parser chokes on these and resolution silently degrades. Remove anything invalid, then restart the IDE and retest with the TButton.Create( check.

5. Isolate third-party IDE packages

IDE experts hook deep into the editor and are a classic cause of Insight failure. Close RAD Studio and relaunch it from the command line with:

bds.exe -p

Run this from a normal command prompt (no admin needed); the -p switch starts the IDE with all known IDE packages disabled. If Insight works in this mode, a package is the culprit. Re-enable them one at a time via Tools → Options → Known IDE Packages, restarting between changes, until Insight breaks again — the last package you enabled is your conflict.

Caution: -p also disables built-in features delivered as packages (Version Insight, modeling, some refactorings), so don't treat a bare IDE as broken if those are missing. Test only Code Insight.

6. Rule out memory pressure

The RAD Studio IDE is a 32-bit process with a practical ceiling around 1.8 GB. In Task Manager, watch bds.exe and DelphiLSP.exe over a working session. DelphiLSP.exe should stay roughly under 800 MB for a typical project; sustained growth past ~1.2 GB indicates a leak. If bds.exe creeps toward its ceiling and Insight degrades as it climbs, memory is the mechanism.

Some engineers apply editbin /LARGEADDRESSAWARE to bds.exe to raise the addressable limit. Treat this as a last resort: it modifies a signed binary, invalidates the digital signature, and can trigger antivirus or SmartScreen warnings. Back up the original executable first, and verify your RAD Studio version's license and support stance before modifying shipped binaries.

7. Check for a parser-blocking syntax error

If Insight works in some units but not others, look for the first syntax error in the failing unit — and in every unit in its uses chain. The parser processes dependencies in order and stops resolving after a blocking error, so one malformed low-level unit can kill Insight everywhere downstream. Fix the first error reported by the compiler (not the last), save, and retest.

Verifying the fix

After each fix, verify with a concrete check rather than a feeling:

1. New VCL project, type TButton.Create( — parameter hint appears within ~500 ms.
2. In the previously broken project, open the LSP Output pane and type in a unit — no new red error lines appear.
3. Ctrl+Space on a project-specific class (not just RTL symbols) — your own symbols appear, proving project indexing completed.

When to escalate

Escalate to Embarcadero support or a QP (Quality Portal) report when you can check all of these boxes:

• Insight fails in a brand-new project with a clean library path.
• It still fails under bds.exe -p (no third-party packages).
• The LSP Output pane shows a reproducible crash or initialization failure.
• DelphiLSP.exe memory is within normal range (ruling out a leak you can only work around).

At that point you've eliminated cache, configuration, add-ins, and resources — what remains is a genuine product defect or environment issue, and your LSP Output log is exactly the evidence a support engineer needs. Attach it, your RAD Studio version and update level, and the minimal project that reproduces the failure.

Limitations

Menu paths and the LSP architecture described here apply to recent RAD Studio versions (11.x and later); older versions using the legacy in-IDE Insight engine behave differently, particularly around DelphiLSP.exe. Memory figures are practical heuristics, not documented limits — treat them as thresholds worth investigating, not proof. Verify behavior against your installed version before modifying any shipped binaries.