RustiC & C++

Fast, GCC-native C/C++ language intelligence for VS Code and VSCodium, powered by a language server written in Rust.

RustiC & C++ is an independently developed language extension for C and C++ projects built with GCC. A native Rust server does the heavy lifting (indexing, name resolution, completion, navigation), and your own gcc/g++ stays the single source of truth for diagnostics, include paths and predefined macros. The result is an editor that answers in a few milliseconds, uses your compiler's real opinion instead of an approximation, and is being built from the ground up to work well with AI-assisted development.

Status: alpha (0.1.x). Feature-rich and under active development, but not yet a drop-in answer for every project. KNOWN_ISSUES.md lists the gaps openly. GCC only: gcc, g++, MinGW and cross GCCs.

Key features

Speed and efficiency

• Native Rust language server. A single ~8 MB binary with no managed runtime, no database service and no background installers. It starts with the editor and talks to it over the Language Server Protocol.
• Single-digit-millisecond answers. On the bundled test projects, median response times were about 6 ms for completion, 4 ms for hover, 3 ms for go to definition and 1 ms for signature help (20 samples each, Linux, VSCodium; see Measuring).
• Fast, incremental indexing. tree-sitter parses files across worker threads, changed files are re-indexed on their own, and open documents are re-analysed as you type.
• Modest memory. The server and its index stayed in the low tens of megabytes on the test projects (about 64 MB resident for the whole workspace session). Memory-bounded and on-disk indexes are on the roadmap.
• Quick recovery. If the server process is killed, the client restarts it and the editor is usable again in about a second.

Accurate by construction

• GCC's own diagnostics. Files are checked with g++ -fsyntax-only; real GCC errors and warnings appear as squiggles and in Problems, with -W… option codes, notes as related information, and GCC fix-its as Quick Fixes (for example Replace 'push_bak' with 'push_back').
• Real compiler facts. Include search order, predefined macros, version and target are asked of your compiler, not guessed. Inactive #if regions are dimmed according to those macros.
• Configuration you already have. .vscode/c_cpp_properties.json (active configuration, variables, compilerPath, includePath, defines, standards, compilerArgs, forcedInclude, compileCommands) and compile_commands.json (including ccache/distcc wrappers, response files and relative paths).

Language intelligence

• Completion for members (., ->), scopes (::), locals, keywords, macros and #include paths, including standard-library class scopes, smart pointers, containers and this.
• Signature help, hover and inlay hints, with overload-aware parameter highlighting, doc comments, constant values, template-function instantiations and optional parameter-name and auto-type hints.
• Navigation: go to definition, declaration, type definition and implementation; find references; document highlights; document and workspace symbols; folding; call hierarchy; header/source switch; semantic tokens.
• Refactoring and editing: cross-file rename, Create Definition from a declaration, Doxygen comment generation (/** + Enter), quick fixes for unresolved includes, and formatting through clang-format (document, range and on-type).
• Build and debug: cppbuild tasks with the $gcc problem matcher, Build and Debug Active File, and a GDB debug adapter with breakpoints (conditional, hit-count, logpoints, function), stepping, variables, watch, pause, threads and setupCommands.

Built for the AI era (roadmap)

LLM-friendly features are a design goal of the architecture, not an afterthought. The server already keeps a structured, queryable model of your code (symbols, scopes, types, references, include graph, compiler facts) that is exactly what an AI assistant needs. The planned work, described in ROADMAP.md, includes:

• Compact, token-budgeted context packs (the symbols, signatures and definitions relevant to a cursor position) for any AI assistant.
• Machine-readable project and compiler facts exposed through a stable command and tool interface.
• Semantic retrieval over the index for chat and agent workflows.
• AI-assisted workflows such as explaining a GCC diagnostic, proposing fix-it edits, and generating documentation, tests and refactors, all checked against the real compiler before they reach your buffer.

These are planned, not shipped. Nothing in 0.1 sends your code anywhere: the extension runs locally, and its only external process is your own compiler.

Why choose this extension?

Choose RustiC & C++ if you build with GCC and want diagnostics that match what your build prints, an editor that stays responsive, and a foundation that is being shaped for AI-assisted development. If you need MSVC or clang support today, the alternative extension available in the market is the better fit; RustiC & C++ refuses those compilers on purpose rather than pretending.

Installation

Requirements

• VS Code 1.77 or newer, or VSCodium.
• gcc/g++ on PATH, or set rusticCpp.compilerPath (or compilerPath in c_cpp_properties.json).
• Optional: gdb (debugging) and clang-format (formatting).
• Windows, Linux or macOS (win32-x64, linux-x64, linux-arm64, darwin-x64, darwin-arm64).

Install

Download the .vsix for your platform from the latest release and verify it against SHA256SUMS.txt, then:

code --install-extension rustic-cpp-<platform>-<version>.vsix      # VS Code
codium --install-extension rustic-cpp-<platform>-<version>.vsix    # VSCodium

or use Extensions: Install from VSIX….

Use one C/C++ language extension per workspace. If another one is installed, disable it for the workspace; two language servers on one file compete for squiggles and navigation.

The extension runs your compiler to query it, so it stays off in untrusted workspaces (Restricted Mode). Trust the folder to enable it.

Usage

1. Open a folder that contains C or C++ sources.
2. Optionally create .vscode/c_cpp_properties.json or generate a compile_commands.json (CMake: -DCMAKE_EXPORT_COMPILE_COMMANDS=ON). With neither, the extension uses the compiler on your PATH and your workspace folder as the include root.
3. Edit as usual: completion, hover, diagnostics and navigation work immediately. Build with Terminal → Run Build Task; debug with F5 after choosing a GDB configuration.
4. Open the Command Palette and type RustiC & C++ for commands such as Restart Language Server, Log Diagnostics, Reload Configuration, Switch Header/Source and Rescan Compilers.

Common settings (all under rusticCpp.*; the full list is in the Settings UI)

When something looks wrong, run RustiC & C++: Log Diagnostics and open the RustiC & C++ output channel. It lists the compiler, its version, the configuration source, every include directory and the flags in use. Include that output in bug reports (CONTRIBUTING.md).

How it works

The editor talks to a thin TypeScript client; the client starts rustic-cpp-server and speaks the Language Server Protocol to it. The server never links a compiler front end. It runs gcc/g++ as a separate process for facts (-E -v, -dM) and for diagnostics (-fsyntax-only -fdiagnostics-format=json), and uses tree-sitter plus its own preprocessor model and scope resolver for everything interactive. That split is what keeps lookups fast and keeps diagnostics honest.

Measuring quality and speed

conformance/ is a public test harness that drives a real VS Code through its public extension API and scores behaviour across about 450 scenarios (completion, hover, navigation, diagnostics, formatting, build, debugging, performance). It can run a single feature or everything:

cd conformance && npm ci && npm run build
npm run conf:list
npm run conf -- --features completion,hover --extension ../client --server ../server/target/release/rustic-cpp-server

A GitHub workflow runs it after every merge to main and on every release. Latency figures in this README come from that harness on a small test corpus; treat them as indicative, not as a benchmark of your project.

Build from source

You need Rust 1.85 or newer, a C compiler (tree-sitter builds a C parser), Node.js 20 or newer, and GCC.

cd server && cargo build --release      # target/release/rustic-cpp-server
cd ../client && npm ci && npm run compile

Press F5 in the repository to launch an Extension Development Host (it builds both parts and opens test-workspace/). cargo test in server/ runs the unit tests. On Windows with MSYS2, keep its bin folder ahead of other toolchains in PATH (see KI-31).

Layout: server/ Rust language server, client/ TypeScript extension, conformance/ test harness, test-workspace/ sample files, .github/ CI, conformance and release workflows. RELEASING.md describes how a release is cut.

Contributing

Bug reports, fixtures from real GCC output and focused pull requests are welcome; see CONTRIBUTING.md. Planned work and priorities are in ROADMAP.md.

License and acknowledgements

• Licensed under the Apache License 2.0 (see also NOTICE). RustiC & C++ is original, independently developed software and contains no code from other language extensions. It is not affiliated with or endorsed by the publishers of any other extension.
• Third-party components: tree-sitter and tree-sitter-cpp (MIT), tower-lsp-server, tokio, serde, serde_json, ropey (MIT or Apache-2.0), vscode-languageclient (MIT).