Clice v1.0 Released: Welcome to Modern C++

Developer ykiko released clice version 1.0, marking the first stable release of an open-source C and C++ language server redesigned on LLVM and Clang. The launch culminates two and a half years of development and over 1,000 commits following four months of alpha testing and nightly builds started July 19, 2026. In ykiko.me's report, the developer confirmed the architecture is stable after extensive testing across open-source codebases.

This coverage examines clice's multi-process compiler engine, native C++20 module support, template pseudo-instantiation, automatic toolchain probing, and command-line refactoring utilities. It is written for software engineers, systems programmers, and tooling teams seeking a resilient language server that handles modern language standards and complex builds without crashing.

01Modern C++23 architecture and hermetic builds

The language server is written entirely in modern C++23 and demonstrates contemporary C++ language idioms operating at scale. The codebase spans hundreds of thousands of lines of code while adopting data-oriented designs, standard ranges, views, expected types, and formatted output. Addressing whether features like modules are ready for production, the developer noted that "they hold up for complex software like clice."

Concurrency across the server is implemented through C++20 coroutines paired with a custom structured-concurrency library built on libuv. The main thread runs an event loop coordinating concurrent operations across worker threads and independent child processes. Serialization across TOML, JSON, bincode, blob, and command-line parameters relies on static reflection with C++20 concepts, achieving declarative annotation without boilerplate.

02Multi-process compilation and worker isolation

Rather than using multithreaded compilation like clangd, clice executes compilation across a pool of isolated child processes modeled after modern web browsers. Incomplete code during interactive editing frequently triggers parser heuristics, compiler crashes, and memory leaks that take down single-process servers. In clice, an unexpected crash in a worker process leaves the central server running so navigation and syntax highlighting remain uninterrupted.

Process isolation also gives the language server fine-grained control over operating system memory limits and compilation task priorities. Crashing workers are recycled cleanly without forcing an entire language server restart or dropping unsaved editor state. This architecture reduces unnecessary resource consumption during background indexing passes on massive multi-file projects.

03Persistent module caching and compilation contexts

Module support covers C++20 named modules out of the box using a standard compile_commands.json compilation database. The server scans module dependencies independently and lazily compiles required module interfaces on demand regardless of the underlying compiler or build system. Precompiled headers and precompiled module interfaces are stored in a persistent local disk cache to ensure instant loading across successive editing sessions.

The system introduces first-class compilation context management for non-self-contained files and shared header inclusions. Users can designate specific compile commands for individual source files or select explicit inclusion points for header files. Non-self-contained files have their parent contexts resolved automatically, while build configurations allow seamless switching between debug and release compilation variants without manual workspace reloads.

04Template pseudo instantiation across fifty toolchains

Template analysis uses a depth-first search pseudo instantiator that resolves dependent names without requiring concrete template argument substitution. Once any template instantiation occurs, clice reuses that context to provide completion within generic lambdas and standard ranges. The engine models templates as duck-typed interfaces, allowing Go to Implementation on dependent calls to display concrete implementations across instantiations alongside matching Find References and Call Hierarchy trees.

Setup friction is eliminated by an integrated environment probing engine that automatically detects and configures more than fifty external toolchains. The prober resolves flag discrepancies and header paths across environments such as nvcc, MSYS2, Cygwin, and zigcc without manual configuration files. Developers can begin working in projects containing non-standard compilers immediately after generating a compilation database.

05Command line indexing and automated modularization

Beyond its language server protocol implementation, clice includes a dedicated command-line interface for batch processing and automated codebase refactoring. The index subcommand builds persistent project indices that allow editors to launch in a warm state immediately. The integrated lint tool runs clang-tidy checks across process pools to merge duplicate header diagnostics, accepting an optional index flag to produce indices during linting.

The refactor utility applies symbol and macro renames directly against the persistent disk index without requiring recompilation, including batch modifications through a specification file. The analyze utility inspects architectural dependencies to detect cyclic relationships, while the modularize subcommand wraps third-party dependencies as C++20 modules. Developers can install the clice extension in Visual Studio Code and other editors to begin working.

clice index
clice lint --index
clice format
clice query
clice refactor --spec
clice modularize