clice, a Clang-based C++ language server, ships its first stable release

The author of clice has announced the project's first stable release. clice is a C/C++ language server written in modern C++ and built on LLVM/Clang. The project recently reached 1,000 commits. Nightly builds began on July 19, 2026, followed by roughly four months of alpha testing, during which many bugs were fixed thanks to feedback from early users. The author also built a testing system and ran extensive tests across many real open-source projects, fixing the issues they exposed. The conclusion: every core feature is now stable and users rarely hit problems in day-to-day use. The author says this is probably the first time the project is being promoted widely, and describes it as the work of the past two and a half years.
Unlike clangd and ccls, which are also Clang-based, clice was redesigned from the ground up to fix architectural problems the author says have gone unsolved in those servers for years. It is written entirely in C++23: C++20 coroutines on top of a libuv-based structured-concurrency async library, C++20 named modules with C++23 import std, and compile-time reflection built on templates and concepts for serialization across TOML, JSON, bincode, blob and command-line arguments. The code is data-oriented, with almost no virtual functions outside the callback interfaces Clang requires. The build is hermetic and reproducible with Bazel and the xclang toolchain, and binaries are optimized with PGO and LTO. The project is self-hosted: module wrappers for third-party libraries are generated by clice modularize, and clice provides module-aware language services on its own codebase. The author's verdict on the debate over whether modules are ready for real work: yes, they hold up for software with hundreds of thousands of lines of code, though the surrounding ecosystem is inconvenient enough that getting the workflow running took a huge amount of effort.
On the language-server side, the author lists five main features. Multi-process compilation: code is compiled in a process pool modeled after modern web browsers, whereas clangd uses multithreading. In clangd a compiler crash takes down the whole server and forces a restart; in clice a lost worker does not affect the rest, so go-to-definition and highlighting keep working, and memory use and compile priorities are easier to manage. Modules and shared caching: full support for C++20 named modules from a compile_commands.json that lists all module files, with dependency scanning, on-demand module builds, and caching of PCHs and PCMs on local disk across sessions. The author says clangd offers only very limited module support and no persistent cache. Compilation context: support for non-self-contained files, with automatic context detection, an explicit choice of compile command or inclusion site, and build configurations such as debug and release. Better template support: a DFS pseudo instantiator infers what many dependent names resolve to without concrete template arguments, and past instantiations feed completion; templates are treated like duck-typed interfaces, so Go to Implementation, Find References and Call Hierarchy work across instantiations. Out-of-the-box experience: most projects need only a compile_commands.json, because clice has built-in environment probing for 50+ toolchains, including nvcc, MSYS2, Cygwin and zigcc. The author adds fixes for many smaller long-standing clangd issues in semantic highlighting, folding and hover, and says that overall clice surpasses clangd in ease of use, feature support and performance. A VS Code extension is available, along with support for other editors.
clice also works from the command line. Subcommands include clice index (a resumable, persistent project index), clice lint (a built-in clang-tidy runner over a process pool), clice format (a parallel clang-format wrapper), clice command (shows the effective compile command after rule rewrites and toolchain probing), clice query (reads the on-disk index and outputs definitions, references, call graphs, hierarchies and file dependencies as JSON), clice refactor (project-wide symbol and macro renames from the index without recompiling), clice analyze (project-structure JSON, including module dependencies and cycles) and clice modularize (wraps third-party libraries as C++20 modules without touching source, and can rewrite a project's own code into module units).
The second half of the post explains why the author did not simply improve clangd. First, maintenance. The author claims clangd has been effectively unmaintained since around 2024, found this out while preparing a PR for better completion inside templates, and understands it to tie back to a shift in Google's C++ strategy: clangd was mainly maintained by several Google engineers, Google began scaling back its Clang investment around 2024, deemed clangd good enough for its internal needs, and reassigned them. Since then, the author says, only Nathan Ridge has been answering questions, unpaid and in spare time, which makes large PRs nearly impossible to handle. That is why clangd's C++20 modules PR dragged on for nearly a year and, per the author, still is not really usable on large projects. Earlier in 2026, Clang's lead maintainer Aaron Ballman posted a call for help on the community forum, as the author reports it, saying clangd is very close to unmaintained, with a heavy backlog of PRs and issues, and hoping to find new community maintainers; otherwise clangd could eventually be removed from the LLVM project.
Second, scale: implementing clice's architectural ideas, such as multi-process compilation, inside clangd would come close to rewriting it, and nobody would review a change that size. Self-hosting with modules would also need sweeping changes to LLVM's build system. Third, LLVM repository constraints: clice depends on third-party libraries such as libuv, simdjson and tomlplusplus, while LLVM requires its repository to stay self-contained. A language server also ships editor extensions and adapters, and the author argues keeping them in the same repository eases maintenance and that LLVM would be unlikely to accept that editor code.
Key facts
- clice, a C/C++ language server built on LLVM/Clang and written in C++23, gets its first stable release after about four months of alpha testing and nightly builds since July 19, 2026; the project recently passed 1,000 commits.
- Its main differences from clangd, per the author: a browser-style process pool so a compiler crash does not take down the server, full C++20 named module support with a persistent on-disk cache, a compilation-context model, better template support, and built-in probing for 50+ toolchains.
- Beyond the server, clice has CLI subcommands: index, lint, format, command, query, refactor, analyze and modularize.
- The author says clangd has been effectively unmaintained since around 2024, with only Nathan Ridge answering questions unpaid, and reports that Clang's lead maintainer Aaron Ballman warned on the community forum that clangd could eventually be removed from LLVM.
- The claim that clice surpasses clangd in ease of use, feature support and performance is the author's own assessment.
Why it matters
clangd is the standard Clang-based language server, and the author says it is used by hundreds of thousands of developers. If the account is right that it has been effectively unmaintained since around 2024 and could eventually be removed from the LLVM project, a stable alternative matters to anyone relying on C++ editor tooling. clice is also a large real-world test of modern C++: written with coroutines, named modules and import std, and run on its own codebase, which the author offers as evidence that modules are usable for software with hundreds of thousands of lines of code.
Who it affects
C and C++ developers who use clangd or ccls in VS Code or other editors, especially those on module-based projects, non-self-contained headers, or unusual toolchains such as nvcc, MSYS2, Cygwin or zigcc. Teams that want command-line indexing, linting, querying or automated refactoring from a persistent index are also in scope. Maintainers of LLVM and clangd are affected by the author's account of staffing problems.
How to use it
Most projects need only a compile_commands.json. For modules, that file should list all module files; clice then scans dependencies and builds required modules on demand, regardless of build system or compiler. You can install the clice extension in VS Code and other editors. From the terminal, clice index builds a persistent index ahead of time so the editor starts warm, and clice lint, format, query, refactor, analyze and modularize cover other workflows. The visible text gives no price or licence terms.
How solid is it
The stability claim rests on about four months of alpha testing, feedback from early users, and a testing system run against many real open-source projects, as described by the author. The comparison with clangd, including the claim that clice surpasses it in ease of use, feature support and performance, is the author's own assessment, and no benchmark figures are given. The account of clangd's maintenance and the link to Google's C++ strategy is the author's understanding; the Ballman forum post is relayed secondhand without a date beyond 2026.
Risks and caveats
This is a release announcement by the project's own author, so the framing is promotional and the clangd criticism is one side of the story. The author says the surrounding module ecosystem is inconvenient enough that getting the workflow running took a huge amount of effort, which could affect users who try to build or adopt module-based setups. The explanation that Google scaled back its Clang investment is hedged by the author as 'from what I understand' and is not an official statement. Whether clangd will in fact be removed from LLVM is not settled; the source only says that could eventually happen without new maintainers.
“Every core feature is now stable, and you rarely run into problems in day-to-day use.”
— The author of clice, in the release announcement