The release of clice v1.0 marks the debut of a C/C++ language server designed to solve architectural flaws that have persisted in industry standards like clangd for years. Built entirely in C++23, clice leverages modern features such as coroutines, named modules, and static reflection to provide a more resilient development environment. Unlike many existing tools, clice isolates compilation tasks into independent processes, ensuring that a single compiler crash does not take down the entire editor's language services.

Architectural Shift to Multi-Process Stability

A primary differentiator for clice is its multi-process compilation model, which mirrors the architecture of modern web browsers. While clangd uses multithreading, clice spawns isolated child processes for each compilation task. This design ensures that if a compiler crashes—a common occurrence when processing incomplete or 'broken' code during active editing—only that specific worker is lost.

By isolating these failures, clice maintains the availability of other language services such as highlighting and symbol navigation. This approach also allows for more granular memory management and the ability to prioritize specific compilation tasks without risking the stability of the main server process.

“In clice, compilation happens in isolated child processes: losing one worker does not affect the rest of the server, so go-to-definition, highlighting, and other services keep working.”

— clice v1.0 Released: Welcome to Modern C++
Side-by-side comparison of clangd and clice handling a crash during completion
A comparison showing how clice maintains service availability while clangd's process crashes during a completion request.ykiko.me

This visual demonstrates the multi-process architecture's ability to isolate crashes and maintain editor functionality.

Modern C++ Features and Module Support

clice is built to demonstrate the viability of modern C++ features in large-scale software. It utilizes C++20 coroutines for complex asynchronous logic and C++20 named modules for its own internal structure. The project is fully self-hosted, meaning it uses its own module-aware services to provide language features for its own codebase.

For users, clice offers robust C++20 module support, including the ability to scan dependencies and lazily build required modules on demand. It also implements a DFS pseudo-instantiator that can infer dependent names in templates without requiring full instantiation, improving the accuracy of 'Go to Implementation' and 'Find References' for complex types.

Comparison of clangd and clice handling C++20 module completion and navigation
Demonstrating clice's support for C++20 named modules, including doc comment hovering and navigation.ykiko.me

This image illustrates the robust module support and navigation features described in the modern C++ section.

Completion of a dependent name inside a template with an auto parameter
clice providing accurate completion for complex templates and auto parameters in a lambda.ykiko.me

This visual supports the claim regarding the DFS pseudo-instantiator's ability to handle complex template types.

Development Motivation and Trade-offs

The creator of clice notes that clangd has faced significant maintenance hurdles since 2024, with a shift in Google's C++ strategy leading to a lack of long-term maintainers. Furthermore, the LLVM repository's strict requirements for self-contained builds make it difficult to integrate the high-performance third-party libraries (like libuv or simdjson) that clice uses to improve the user experience.

While clice aims to surpass clangd in ease of use and performance, it remains a Clang-based indexer. Some users point out that Clang-based tools can be significantly slower than non-Clang indexers, which may present a trade-off for developers working on massive codebases where indexing speed is a primary concern.