deniz.in

Markets

Weather

Loading weather

· via Hacker News – Front Page (native)

clice 1.0 ships stable C++23 language server with process isolation and module support

The C++ language server clice has released version 1.0 after roughly four months of alpha testing, offering process-isolated compilation, full C++20 module support and a self-hosted C++23 codebase.

clice 1.0 ships stable C++23 language server with process isolation and module support

clice reaches its first stable release

clice, an open-source C and C++ language server written entirely in modern C++, has shipped version 1.0. According to the release announcement from the project's developer, the milestone follows roughly four months of alpha testing driven by nightly builds that began on July 19, 2026, and arrives as the project passes 1,000 commits. The developer, who has spent the past two and a half years on the project, says every core feature is now stable and that problems in day-to-day use are rare, which is why the first stable release is being made now. The announcement surfaced on the Hacker News front page and appears to be the project's first wide promotion.

A language server that doubles as a modern C++ showcase

Like clangd and ccls, clice is built on LLVM/Clang, but it is a ground-up redesign intended to fix architectural problems the developer says have gone unsolved in those servers for years. The codebase is written in C++23 and serves as evidence that modern C++ holds up in large, real-world software:

  • Asynchronous logic is written with C++20 coroutines on top of a custom libuv-based structured-concurrency library. The program runs an event loop on the main thread while coordinating multiple threads and multiple processes via IPC.
  • The whole project uses C++20 named modules and C++23 import std, and it is fully self-hosted: clice generates module wrappers for third-party libraries through its modularize command and provides module-aware language services on its own codebase.
  • Serialization for TOML, JSON, bincode, blob and command-line arguments is handled by static reflection built on templates and C++20 concepts, using declarative annotations rather than hand-written glue code.
  • The design is data-oriented, with almost no virtual functions outside the callback interfaces Clang requires, and it leans on std::format, std::expected, std::ranges and std::views instead of legacy APIs.
  • The Bazel-powered build is hermetic and reproducible, compiled with a unified toolchain for cross-platform work, optimized with PGO and LTO, and produces binaries that depend only on system libraries.

The developer cautions that while the language features themselves proved workable at a scale of hundreds of thousands of lines, the surrounding ecosystem is still inconvenient enough that wiring the whole workflow together took considerable effort.

Where the architecture diverges from clangd

The headline design difference is the compilation model. clice compiles code in a browser-style pool of worker processes, whereas clangd uses multithreading. The rationale, per the announcement, is that C++ is complex enough that the compiler can crash or leak memory on corner cases — especially half-written code mid-edit, which sees far less testing than complete code. In clangd a compiler crash takes down the whole server and forces a restart; in clice a lost worker leaves the rest of the server and its features running. Process isolation also makes memory usage and compilation scheduling easier to manage.

Module support is another differentiator. Given a compile_commands.json that includes module files, clice scans dependencies on its own and lazily builds required C++20 named modules on demand, independent of build system or compiler, with completion, highlighting, go-to-definition and hover all module-aware. Precompiled headers and module files are cached on disk and reused across sessions. By comparison, the announcement notes clangd offers only limited module support with no persistent cache.

Other features include a compilation context system for non-self-contained files — automatically detecting which compile command or inclusion site applies to a header — plus grouping of compile commands into switchable build configurations such as debug and release. For templates, a depth-first pseudo-instantiator infers what dependent names resolve to without a full instantiation, and templates are treated as duck-typed interfaces whose instantiations act like implementations, enabling go-to-implementation, find-references and call hierarchy across all instantiations. The server also probes more than 50 toolchains out of the box, including nvcc, MSYS2, Cygwin and zigcc, handling compiler mismatches without manual flag configuration. The developer's overall claim is that clice surpasses clangd in ease of use, feature support and performance, and a VS Code extension is available now.

A CLI as well as a server

Beyond language-server duty, clice exposes subcommands: index builds a resumable persistent project index so the editor starts warm; lint runs clang-tidy concurrently across the process pool and merges duplicate header diagnostics; format wraps clang-format and locates files from config or the compilation database; command shows effective compile commands after rule rewrites and toolchain probing, or resolves them for other Clang tools.

Why it matters

clangd is the default C++ language server in most editors, and its long-standing gaps — fragile module support, whole-server crashes and fiddly configuration — shape the daily experience of C++ developers everywhere. clice argues those problems are architectural rather than inevitable, and version 1.0 turns that argument into a testable artifact. Just as significantly, the project is a working proof at scale that C++20 modules, coroutines and C++23 features are ready for production use — though the developer's own account of ecosystem friction suggests the tooling around the language still has catching up to do.

  • #cpp
  • #language-server
  • #clang
  • #llvm
  • #developer-tools
  • #open-source

Related posts