⏱️ Reading time: 9 min
Clice reached version 1.0 on November 15, 2026, after four months of alpha testing that began on July 19 and surpassed 1,000 commits in its repository, according to the announcement from creator ykiko. It is a language server for C and C++ written entirely in C++23, designed to replace clangd or ccls in your editor.
📑 En este artículo
- A C++ language server that doesn’t crash entirely when the compiler blows up
- One process per file, not a shared thread
- C++20 modules with on-disk caching, not just partial support
- Compilation context: the problem of headers that don’t compile on their own
- Clice versus clangd and ccls
- What this means for you if you maintain a large C++ project
- What the community is debating: how ‘modern’ is modern
- Limitations and when to hold off before migrating
- References
The project has been in development for two and a half years and relies, like its two predecessors, on LLVM and Clang to understand code. But clice is not a fork or an incremental improvement of either one: its author redesigned it from scratch to solve architectural problems that clangd and ccls have carried for years, particularly what happens when the compiler crashes in the middle of an edit (source).
A C++ language server that doesn’t crash entirely when the compiler blows up
Like any Language Server Protocol implementation, clice doesn’t depend on a specific editor: any LSP client (VS Code, Neovim, Emacs, Helix) can connect to it for syntax highlighting, autocomplete, go-to-definition and the other usual services. The gain from using clice instead of clangd isn’t on the editor side, it’s in what happens on the other end of the protocol when the compiler has a bad day.
One process per file, not a shared thread
clangd compiles with multiple threads inside a single process. The problem is that Clang can crash or leak memory in edge cases, something far more common than it seems when you’re editing half-written code: the vast majority of people who test a compiler do it against complete code, and almost nobody tests against incomplete code, which is exactly where the compiler falls back on best-effort heuristics (source). When that happens in clangd, the entire server restarts, and you lose go-to-definition, highlighting and autocomplete until it comes back up.
clice solves this with a process pool, similar to a modern browser. Each compilation runs in an isolated child process: if one worker crashes, the rest of the server keeps responding, and features that depend on other files aren’t interrupted. That design also makes it easier to manage memory and prioritize what gets compiled first, something a shared-thread model inside a single process can’t do with the same granularity (source).
Underneath, all of this runs on a structured concurrency library built on libuv and C++20 coroutines. A single event loop on the main thread coordinates both the child processes, via IPC, and the server’s own internal threads, which lets clice behave like a complex concurrent program without the explosion of locks and race conditions typical of that kind of architecture (source).
C++20 modules with on-disk caching, not just partial support
The other gap clice targets is C++20 module support. With a compile_commands.json that includes the module files, clice scans dependencies on its own and builds what it needs lazily, regardless of which build system or compiler you use. That covers autocomplete, highlighting, go-to-definition and hover inside module files, something clangd still offers only in a very limited way and without persistent caching (source).
The PCH and PCM files clice builds are saved to disk and reused across sessions, so you don’t have to rebuild the entire module tree every time you open the editor. The project even includes its own tool that automatically generates module wrappers for third-party libraries, and clice runs on its own source code to provide itself with its own module-aware services (source).
The rest of the technical stack follows the same logic. To serialize data (TOML, JSON, bincode, and its own command-line arguments) it uses static reflection built with C++20 templates and concepts, with declarative annotations similar to Rust macros and without manual boilerplate (source). The design is data-oriented, with almost no virtual functions outside the callback interfaces Clang requires, and it relies on std::format, std::expected, std::ranges and std::views instead of the older C++98/11 APIs.
The build is hermetic and reproducible with Bazel, using a unified toolchain for consistent cross-compilation across platforms. Binaries ship optimized with PGO and LTO, and the build artifacts depend on nothing beyond system libraries (source).
Compilation context: the problem of headers that don’t compile on their own
Many C++ headers aren’t self-contained: they depend on which file includes them to make sense, and the same header can be used from dozens of different inclusion points with different configurations. clangd handles this implicitly and sometimes inconsistently. clice, instead, explicitly models the concept of compilation context: you can choose which compile command applies to a source file, or from which inclusion site a header should be interpreted (source).
When you open a header that isn’t self-contained, clice detects its context automatically, so it works without extra configuration from the first use. But it also lets you group compile commands into full configurations, for example to switch between a debug build and a release build without losing the rest of the editor’s state (source). In projects with several build configurations active at once, that avoids false-positive errors that are really just the wrong context.
Clice versus clangd and ccls
clangd is today’s most widely used alternative: also based on Clang and maintained within the LLVM project itself. ccls is the other known option in the same space, lighter weight and also dependent on Clang, though this article’s source doesn’t detail its module support, so we don’t compare it on that column (source). The table below summarizes how clice differs from clangd, the two projects with enough data to compare directly:
| Aspect | clice | clangd |
|---|---|---|
| Compilation architecture | Pool of isolated processes | Multithreaded within one process |
| Effect of a compiler crash | Only affects that worker | Restarts the entire server |
| C++20 module support | Full, with automatic scanning | Very limited |
| PCH/PCM caching | Persistent on disk across sessions | Not persistent |
For a small team that already lives fine with clangd’s current limits, switching right away isn’t justified: clice’s main payoff shows up when the team edits large files with heavy templates or modules, exactly the cases where Clang’s compiler is most fragile. ccls remains the lightest option to install when the goal is just basic autocomplete, without expecting advanced module support.
What this means for you if you maintain a large C++ project
If you work on backend or infrastructure with a large C++20 or C++23 codebase, and you currently use clangd, the first check is simple: does your editor restart on its own when you edit a half-finished file? If the answer is yes, that’s exactly the problem clice targets at the root with its process pool. Trying it first on a personal branch, without migrating the whole team the same day, is the cheapest way to confirm it.
If your project also already uses or is evaluating C++20 modules, the check is different: you need a compile_commands.json that includes the module files. With that, clice can give you autocomplete and navigation inside modules without having to rebuild anything manually every time you open the editor, something clangd doesn’t currently give you (source). If your team hasn’t touched modules yet, the immediate gain is still server stability, not modules.
If your build infrastructure already uses Bazel, or you’re evaluating a move to a hermetic build, clice also works as a real implementation reference: a project of the scale its own announcement describes, compiled with PGO and LTO and with no dependencies outside system libraries. If you’re deciding whether that investment pays off for your CI pipeline, clice’s case is a concrete comparison point (source).
What the community is debating: how ‘modern’ is modern
In the Hacker News thread about the release, part of the conversation centered on the project’s own name. User omoikane suggested that ‘modern C++’ likely refers to Scott Meyers’ book Effective Modern C++, used to contrast standards after C++98/11 with that earlier era of the language (comment).
That reading matters beyond the anecdote. clice doesn’t use ‘modern’ as a marketing adjective: every feature it chooses (coroutines, modules, static reflection, concepts) corresponds to something C++98/11 didn’t have, and that many large production projects still don’t use today. The language server’s own architecture works as proof that those features hold up under hundreds of thousands of lines of complex software, not just blog examples (source).
Limitations and when to hold off before migrating
clice is new software. Four months of alpha with real feedback from early users is a short track record compared to the years in production that clangd and ccls have, although the author himself maintains that the core features are already stable in daily use (source).
The C++20/23 ecosystem is still rough around the edges. The creator himself admits that getting that entire workflow (modules, hermetic Bazel builds, the xclang toolchain) working end to end took considerable effort tracking down issues and adapting things by hand (source). If your project doesn’t use Bazel or modules, part of that infrastructure investment doesn’t help you yet, and you’ll depend on your own build system correctly generating compile_commands.json.
The real risk of adopting clice now isn’t a single failure: it’s a new bug in a tool that just turned four months old interrupting you mid-sprint, exactly the kind of friction a language server is supposed to eliminate. Try it first on a secondary repo or your own environment, not on the whole team’s machines the same day it’s released. There’s also no public adoption data yet (downloads, number of projects in production) beyond the 1,000 commits and four months of alpha the announcement itself reports.
References
- clice v1.0 Released: Welcome to Modern C++: official release announcement, multiprocess architecture, module support and build details.
- Hacker News thread on the clice 1.0 release: community discussion about the project.
- omoikane’s comment on Hacker News: hypothesis on the origin of the term ‘modern C++’ tied to Scott Meyers’ book.
Featured image: Foto de Vishnu Kalanad en Unsplash
How each article is made (sources, testing and editorial criteria): How we work.
Did it work for you? Got a different error? Say so below: questions get answered and help the next reader.
Leave a comment
0 Comments