# EasyClangComplete gives Sublime Text a real Clang based C and C++ completion engine

> EasyClangComplete is a Sublime Text plugin that replaces Sublime's own parsing with libclang, so completions in C, C++, Objective-C and Objective-C++ reflect the actual compiler flags and include paths of your project. It is a Python plugin driven by a compilation database, and it can build that database itself from CMake or from a Bazel target.

**niosus/EasyClangComplete** — :boom: Robust C/C++ code completion for Sublime Text 3/4

- Repository: https://github.com/niosus/EasyClangComplete
- Website: https://niosus.github.io/EasyClangComplete/
- Stars: 579 · Forks: 77
- Language: Python
- License: MIT
- Published: 2026-10-22 · Updated: 2026-10-22 · Language: en
- Canonical page: https://hysenlabs.com/projects/niosus-easyclangcomplete

## Sublime's own C parser does not know your compiler flags

EasyClangComplete is a plugin for Sublime Text 3 for easy to use, out of the box autocompletions for C, C++, Objective-C and Objective-C++. The repository description calls it robust C/C++ code completion for Sublime Text 3 and 4, and the topics list both sublime-text-3 and sublime-text-4, so the plugin spans the two major Sublime generations.

The problem it solves is specific and well understood by anyone who has written C in a lightweight editor. Sublime Text has its own parser for C family languages, and that parser has no knowledge of the compile flags your project actually uses. It does not know your include directories, it does not know which macros you define, and it cannot see a project layout where headers live in places the default search path does not cover. The result is completions that are subtly wrong, or missing, or offer a symbol that will not compile.

The fix is to stop guessing and ask the compiler. The plugin delegates to libclang, the same library that powers the C language support in most modern IDEs, so the completions come from parsing your code with your actual configuration. The topic list names libclang directly, and the dependency files in the repository include an external/ directory, which is where the bundled native component sits.

The consequence is that the plugin is only as good as your build configuration, which is why the setup steps in the README spend most of their length on getting the compiler flags and include folders right. The plugin does not have a way to guess what your project needs; it needs to be told.

## Three steps, and the second one is the important one

The README frames the setup as a simple start in just 3 steps, and the first is installing the plugin.

You press CTRL+Shift+P in Sublime Text and install EasyClangComplete using Package Control. The repository has a .no-sublime-package file at the root, which is the marker that tells Package Control this is a plain GitHub repository rather than one published in its own index, and the README's download link points at the Package Control page for EasyClangComplete.

The second step is installing clang itself, and the README covers the platforms one by one. On Ubuntu you install it with apt-get, on OSX it ships with clang by default, and on Windows you install the latest release from the clang website. The command for the Linux case is:

```bash
sudo apt-get install clang
```

On other systems you use your package manager or the clang website again, and the README links the download page at llvm.org.

The third step is the one that decides whether completion works: configure your compiler flags and include folders. This is where the plugin stops being a convenience and becomes a build configuration consumer, and it is the step most people get wrong.

The key point for the Windows case is that the plugin is not self-contained. libclang has to be present on the machine, and the README's link list even includes a reference to a libclang issue, which suggests installation problems on that platform are a recurring topic.

## CMake and Bazel are handled by the plugin itself

The configuration step has a shortcut for the two build systems most C and C++ projects use, and it is the strongest argument for the plugin.

If you use CMake, the README says you are in luck: the plugin will run cmake on a proper CMakeLists.txt in your project folder and will use information from it to complete your code out of the box. So the plugin invokes CMake, reads the project, and derives the flags and include paths from the same file your build uses. There is no second copy of the configuration to maintain, which is the failure mode of every other approach to this problem.

Bazel is supported on Linux and MacOS only. The plugin ships a command called Generate compilation database, which produces a compile_commands.json in the source folder of your project, and the plugin then takes it from there. That file is the compilation database format, and it is the interchange point between build systems and language tooling.

If you use neither, the README points at the configuration documentation, which describes the other ways to tell the plugin about your flags and include folders. The repository root reinforces that this is a configuration-heavy tool: there is a .clang_complete file, a Dependencies.sublime-settings, a Preferences.sublime-settings, a Default.sublime-commands and a Main.sublime-menu, so the plugin exposes its own settings and commands inside Sublime's own configuration system.

## The plugin drives libclang through a small set of Sublime entry points

The repository layout shows a fairly conventional Sublime plugin with an unusual amount of machinery around it. The main plugin file is EasyClangComplete.py at the root, with a plugin/ directory holding the implementation and an external/ directory for the bundled native pieces. There is a dependencies.json, a messages.json and a messages/ directory, which are the Package Control plumbing for dependencies and translated strings. A .coveragerc sits next to the tests/ directory and a unittesting.json, and mkdocs.yml at the root indicates the documentation site is built with MkDocs from the docs/ directory.

The Sublime-specific integration points are the settings and command files. Default.sublime-commands gives the plugin its palette entries, Default.sublime-keymap binds the keys, and Main.sublime-menu puts the entries in the editor menu. That is the standard way a Sublime plugin exposes itself, and it means the plugin is invoked through Sublime's own command palette rather than through a separate binary.

The coverage badge in the README points at codecov for the master branch, and there is a GitHub Actions badge, so the project has a continuous integration setup and reports coverage on it.

One structural detail is worth noting for anyone who wants to extend it. There is a .github/CONTRIBUTING.md, which the README links as the contribution guide, and the README asks contributors to open an issue if something is unclear or a pull request if they want to implement missing functionality or fix a bug. The project is written in Python, which is the language Sublime Text itself embeds, so a contributor needs no separate toolchain to work on it.

## The release history has not moved in four years

The maintenance picture is the thing to weigh before you commit to a workflow around this plugin.

The last push was on 2026-06-09 and the repository is not archived, so the code is not being deleted and there is recent activity. But the release list tells a different story about shipped versions: 6.5.2 on 2021-12-19, 6.5.1 on 2021-01-10 and 6.5.0 on 2020-12-22. The most recent tagged release is more than four years old, and the version numbers have not moved since.

That gap matters more for a plugin than for a library, because a plugin has to keep working with the editor it runs in. Sublime Text 4 shipped after Sublime Text 3, and the repository topics list both, and the description says the plugin supports 3 and 4, so the code does handle the newer editor. The question is what a commit on master buys you if Package Control is still serving the 6.5.2 tag, and the README does not document a channel or a beta distribution for the newer code.

The dependency on libclang is the other moving part. The plugin's correctness depends on a clang version that keeps changing, and the README's instruction to install the latest release from the clang website on Windows means the plugin is running against whatever clang the user happened to install.

The licence is MIT, with a LICENSE file at the repository root, so there is no copyleft constraint on using or modifying it, which is a licensing note rather than legal advice. The project also has a support page, an OpenCollective link, and a set of older donation platform links in the badge list, which tells you funding has been arranged in several places over the years.

## Where a full IDE is the better trade

The obvious alternative is a real IDE with Clang integration, such as the ones built on the same libclang the plugin uses. The difference in approach is that an IDE owns the whole project model, with a project index, a symbol database, refactoring and a debugger attached, and it maintains compatibility with your compiler continuously as a product requirement.

EasyClangComplete gives you the completion engine without the IDE, inside an editor that is fast to start and does not rearrange your files. If you already keep a build working in a terminal and use Sublime for editing, that is a reasonable arrangement, and the plugin is the piece that makes it hold together for C and C++ specifically.

There is a second alternative worth naming, which is to use a language server. The C and C++ language server, clangd, is the same analysis machinery pointed at a different interface, and editors that support LSP can consume it. The difference is in what the plugin does with the project configuration: it can run CMake itself and derive the flags, whereas a language server expects a compilation database to exist already. If your project already generates compile_commands.json through your build, clangd in an LSP-capable editor is a shorter path.

The limitation to keep in mind is that the plugin's accuracy is borrowed. It is only as correct as the flags it is given, and when the flags are wrong the completions are wrong in a way that is hard to distinguish from a bug in the plugin. Projects with unusual build systems, generated headers, or a heavy macro layer are where this bites, and the README's answer is to configure the plugin by hand, which is where the documentation link becomes the essential reading rather than the optional one.

## Conclusion

Adopt EasyClangComplete if you edit C or C++ in Sublime Text and your completions are wrong because Sublime's own parser does not understand your project flags or include paths, since the plugin delegates to the same compiler you build with. Do not adopt it if you are happy with a lightweight editor setup, or if your project uses a toolchain that libclang cannot parse, because the accuracy comes from that dependency. Verify first that clang is installed and on your PATH, that the plugin can find your compilation database, and that the version you install matches the Sublime Text version you run, since the plugin targets Sublime Text 3 and 4.

## FAQ

### What does EasyClangComplete do for Sublime Text?

It is a plugin for Sublime Text 3 and 4 that provides out of the box autocompletion for C, C++, Objective-C and Objective-C++, using libclang rather than Sublime's own parser, so completions reflect the compiler flags and include folders of your project.

### How do I install EasyClangComplete?

Press CTRL+Shift+P in Sublime Text and install EasyClangComplete using Package Control. You also need clang installed: on Ubuntu with apt-get, on OSX it ships by default, and on Windows from the clang website at llvm.org. Then configure your compiler flags and include folders, which is the step that decides whether completions are accurate.

### Does EasyClangComplete work with CMake and Bazel?

Yes. With CMake the plugin will run cmake on a proper CMakeLists.txt in your project folder and use that information to complete your code. With Bazel, supported on Linux and MacOS only, you can run the Generate compilation database command shipped with the plugin, which produces a compile_commands.json in the source folder.

### Is EasyClangComplete still maintained?

The last push was on 2026-06-09 and the repository is not archived, but the most recent release is 6.5.2 from 2021-12-19, with 6.5.1 in January 2021 and 6.5.0 in December 2020. The licence is MIT.

### How do I contribute to EasyClangComplete?

The project is written in Python, which Sublime Text embeds, so no separate toolchain is needed. The README asks you to open an issue if something is unclear or a pull request to implement missing functionality or fix a bug, and points to the contribution guide in .github/CONTRIBUTING.md.

## Sources

- [License: MIT](https://github.com/niosus/EasyClangComplete/blob/master/LICENSE)
- [niosus/EasyClangComplete on GitHub](https://github.com/niosus/EasyClangComplete)
- [Project website](https://niosus.github.io/EasyClangComplete/)
- [README](https://github.com/niosus/EasyClangComplete/blob/master/README.md)
- [Releases](https://github.com/niosus/EasyClangComplete/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/niosus-easyclangcomplete