HackerReposA FIELD GUIDE TO OPEN SOURCE
ProSponsor the shelf♧ 0
← Back to top all-time
Andersbakken
rtags
C++2014–2021
Andersbakken / rtags

rtags

A client/server indexer for c/c++/objc[++] with integration for Emacs based on clang.

Developer ToolsSystems & Infrastructure
Explore on GitHubRead Hacker News discussions
20Distinct people
23Mentions
1Explicit recommenders
1.8KGitHub stars
REPOSITORY AT A GLANCE

What to know before exploring

What it is

A client/server indexer for c/c++/objc[++] with integration for Emacs based on clang.

GitHub

Where it is used

No documented product use was verified in the last source check.

What people are saying

No mention of any LanguageServer implementation? I highly recommend rtags (even if it's not stricly LSP) https://github.com/Andersbakken/rtags

OlivierLi used a recommendation phrase. One indexed comment matches. This is a phrase match, not a verdict.

No classified warning is attached to this page. Read the discussions before treating silence as approval.

Also in these discussions

Mentioned in the same Hacker News threads. That is not proof they are substitutes.

This week on Hacker News

Nov 7–Nov 14 UTC · Direct repository links and separately labeled related project stories. Indexed through 11/14/2026, 1:49:46 PM UTC.

No direct repository links were found in the indexed HN discussions over the past seven days. Older discussions are available below.

Mentions over time

HN mentions by year23 dated mentions

Observed mentions: 2014-08-24 08:31:52 UTC to 2021-02-09 18:40:51 UTC.

024682014-01-01 00:00:00 UTC to 2015-01-01 00:00:00 UTC (exclusive): 6 mentions; 0 submissions, 6 comments20142015-01-01 00:00:00 UTC to 2016-01-01 00:00:00 UTC (exclusive): 2 mentions; 0 submissions, 2 comments2016-01-01 00:00:00 UTC to 2017-01-01 00:00:00 UTC (exclusive): 8 mentions; 1 submissions, 7 comments2017-01-01 00:00:00 UTC to 2018-01-01 00:00:00 UTC (exclusive): 1 mentions; 0 submissions, 1 comments20172018-01-01 00:00:00 UTC to 2019-01-01 00:00:00 UTC (exclusive): 2 mentions; 0 submissions, 2 comments2019-01-01 00:00:00 UTC to 2020-01-01 00:00:00 UTC (exclusive): 3 mentions; 0 submissions, 3 comments2020-01-01 00:00:00 UTC to 2021-01-01 00:00:00 UTC (exclusive): 0 mentions; 0 submissions, 0 comments2021-01-01 00:00:00 UTC to 2022-01-01 00:00:00 UTC (exclusive): 1 mentions; 0 submissions, 1 comments2021

Counts come from the repository’s dated source evidence. Index cutoff: 2026-11-02 08:16:59 UTC.

View mention counts and date ranges
UTC ranges include their start and exclude their end. Select a period to filter the source evidence.
PeriodStart (UTC)End (exclusive, UTC)MentionsSubmissionsComments
20142014-01-01 00:00:00 UTC2015-01-01 00:00:00 UTC606
20152015-01-01 00:00:00 UTC2016-01-01 00:00:00 UTC202
20162016-01-01 00:00:00 UTC2017-01-01 00:00:00 UTC817
20172017-01-01 00:00:00 UTC2018-01-01 00:00:00 UTC101
20182018-01-01 00:00:00 UTC2019-01-01 00:00:00 UTC202
20192019-01-01 00:00:00 UTC2020-01-01 00:00:00 UTC303
20202020-01-01 00:00:00 UTC2021-01-01 00:00:00 UTC000
20212021-01-01 00:00:00 UTC2022-01-01 00:00:00 UTC101

From the project README

An excerpt from the repository, fetched Nov 13, 2026.

Read the project’s introduction
rtags rtags-xrefac-rtagscompany-rtagsflycheck-rtagshelm-rtagsivy-rtags Introduction RTags is a client/server application that indexes C/C++ code and keeps a persistent file-based database of references, declarations, definitions, symbolnames etc. There’s also limited support for ObjC/ObjC++. It allows you to find symbols by name (including nested class and namespace scope). Most importantly we give you proper follow-symbol and find-references support. We also have neat little things like rename-symbol, integration with clang’s “fixits” (https://clang.llvm.org/diagnostics.html). We also integrate with flymake using clang’s vastly superior errors and warnings. Since RTags constantly will reindex “dirty” files you get live updates of compiler errors and warnings. Since we already know how to compile your sources we have a way to quickly bring up the preprocessed output of the current source file in a buffer. While existing taggers like gnu global, cscope, etags, ctags etc do a decent job for C they often fall a little bit short for C++. With its incredible lexical complexity, parsing C++ is an incredibly hard task and we make no bones about the fact that the only reason we are able to improve on the current tools is because of clang (https://clang.llvm.org/). RTags is named RTags in recognition of Roberto Raggi on whose C++ parser we intended to base this project but he assured us clang was the way to go. The name stuck though. Tarball releases are available here: https://github.com/Andersbakken/rtags/releases/ TLDR Quickstart We assume you have something to generate a JSON Compilation Database for your project. Your build system probably has a way to generate it, or you can look at something like Bear. Build RTags git clone --recursive https://github.com/Andersbakken/rtags.git cd rtags cmake -DCMAKE_EXPORT_COMPILE_COMMANDS=1 . make Start the RTags daemon (rdm) ./bin/rdm & Index the RTags project, and wait until rdm is silent ./bin/rc -J . Open source file in emacs emacs +74:34 src/rdm.cpp Load rtags.el M-: (load-file "rtags.el") RET Ensure rc can be found M-x set-variable RET rtags-path RET "../bin" RET Call rtags-find-symbol-at-point M-x rtags-find-symbol-at-point RET Your location is now on the definition of Server::instance() Documentation The documentation can be found in the Wiki. Disclaimer RTags is still under development and is not the most stable piece of software you’ll ever find. We’re constantly working to improve on it.
Read the full README on GitHub

What Hacker News says

23 sources
peter_d_sherman·Feb 9, 2021
>"List of projects and tools https://github.com/Andersbakken/rtags/ "RTags is a client/server application that indexes c/c++ code and keeps a persistent in-memory database of references, symbolnames, completions etc." https://rprichard.github.com/sourceweb/ "A C/C++ source code indexer and navigator" https://github.com/etaoins/qconnectlint "qconnectlint is a Clang tool for statically verifying the consistency of signal and slot connections made with Qt's QObject::connect." https://github.com/woboq/woboq_codebrowser "The Woboq Code Browser is a web-based code browser for C/C++ projects. Check out https://code.woboq.org/ for an example!" https://github.com/mozilla/dxr "DXR is a source code cross-reference tool that uses static analysis data collected by instrumented compilers." https://github.com/eschulte/clang-mutate "This tool performs a
Read the rest
number of operations on C-language source files." https://github.com/gmarpons/Crisp "A coding rule validation add-on for LLVM/clang. Crisp rules are written in Prolog. A high-level declarative DSL to easily write new rules is under development. It will be called CRISP, an acronym for Coding Rules in Sugared Prolog." https://github.com/drothlis/clang-ctags "Generate tag file for C++ source code." https://github.com/exclipy/clang_indexer "This is an indexer for C and C++ based on the libclang library." https://github.com/holtgrewe/linty "Linty - C/C++ Style Checking with Python & libclang." https://github.com/axw/cmonster "cmonster is a Python wrapper for the Clang C++ parser." https://github.com/rizsotto/Constantine "Constantine is a toy project to learn how to write clang plugin. Implements pseudo const analysis. Generates warnings about variables, which were declared without const qualifier." https://github.com/jessevdk/cldoc "cldoc is a Clang based documentation generator for C and C++. cldoc tries to solve the issue of writing C/C++ software documentation with a modern, non-intrusive and robust approach." https://github.com/AlexDenisov/ToyClangPlugin "The simplest Clang plugin implementing a semantic check for Objective-C. This example shows how to use the DiagnosticsEngine (emit warnings, errors, fixit hints). See also http://l.rw.rw/clang_plugin for step-by-step instructions." https://phabricator.kde.org/source/clazy "clazy is a compiler plugin which allows clang to understand Qt semantics. You get more than 50 Qt related compiler warnings, ranging from unneeded memory allocations to misusage of API, including fix-its for automatic refactoring." https://gerrit.libreoffice.org/gitweb?p=core.git;a=blob_plai... "LibreOffice uses a Clang plugin infrastructure to check during the build various things, some more, some less specific to the LibreOffice source code. There are currently around 50 such checkers, from flagging C-style casts and uses of reserved identifiers to ensuring that code adheres to lifecycle protocols for certain LibreOffice-specific classes. They may serve as examples for writing RecursiveASTVisitor-based plugins.""
In External Clang Examples
rjzzleep·Sep 16, 2019
I think this isn't about unix tools or philosophies. It's about the fact that for a very long time these big monolithic projects didn't really allow any integrations. Vim didn't allow integration because there was no way interface to it, and it's not an easy codebase. Neovims work is proof of that. C++ compilers didn't allow integration because they were big monstrous projects and when you need to do proper c++ indexing you basically need to compile the whole project. For C++ this changed with clang and even for clang it took a lot of iterations and bugs inside of libclang to allow for this capability. Naturally one of the best C++ IDE's was therefore also by the producer of their own compiler (Visual Studio). These boundaries are slowly fading, so these arguments are kinda moot. A few examples: https://clang.llvm.org/extra/clangd/ https:
Read the rest
//github.com/Andersbakken/rtags https://github.com/cquery-project/cquery
In Neovim v0.4.0
dan00·Feb 28, 2019
> I'm a game developer mainly writing/reading/debugging C++ on a codebase that's well over a million lines of code. As with most game-dev I'm developing almost entirely using Visual Studio, and I can't imagine trying to navigate code using a terminal based editor. I'm working with vim on a ~5 million line C++ code base. Thanks to rtags[1] I've all I need: auto completion, goto definition, even semantically correct renaming or finding all locations in code calling a certain function. I'm certainly not saying that it's as polished as 'Visual Studio', but it works pretty well. If tooling isn't baked into an IDE - which unfortunately is often the case - then pretty much every editor with some kind of extension mechanism can take advantage of it. > Maybe it's just because this is what I'm used to, however I just don't see how some of the tools
Read the rest
would even be displayed in a terminal (parallel stacks window, for example) without some horrible ascii node graph. Yes, most visualization are text based. E.g. for showing the references for a function rtags uses the Quickfix-window of vim, which pretty much is just a list with one entry for every reference. I can now jump to every occurence in the list or even execute an operation on every reference, like I've removed the last parameter of the function call, and now I'm defining a vim substitution command for removing the last parameter and execute it on very item of the Quickfix-window. Sometimes visualizations are certainly helpful, but I never found them particular useful for software, because the more complex an application gets, the less useful the visualizations become. At some point you're less interested on the class level and more on the system level, but tools can't that easily detect what are the systems in an application. [1] https://github.com/Andersbakken/rtags
In How I'm still not using GUIs in 2019: A guide to the terminal
ekoczwara·Nov 4, 2018
So I've played with this some more. I've cleaned up everything, sourced environment-setup from my sdk, configured project with cmake, and now rtags-find-symbol-at-point can't find <iostream> (which is somewhere under /opt/etos/1.2/sysroots), rdm complains 'handleInclude failed (nil) ...' (https://pastebin.com/u39EGzdX). As 'Disclaimer' in https://github.com/Andersbakken/rtags/blob/master/README.org says: 'RTags is still under development and is not the most stable piece of software you’ll ever find.'. Bugtracker on github has 123 opened issues. Do you consider RTags as serious option?
In Ask HN: How to work with modern C++ using Emacs?
unhammer·Aug 11, 2016
For C++, I use https://github.com/abingham/emacs-ycmd which gives completion (uses company-mode) and code navigation. It can also do C, C#, js, go, python etc. Requires a little setup (you have to install the ycmd daemon and, depending on language, a per-project conf file), but worth it. An alternative to ycmd is https://github.com/Andersbakken/rtags which I think can list all usages of a symbol – ycmd only lets you go from usage to definition. I like how ycmd.el runs the ycmd daemon for me though.
In Intero for Emacs: complete interactive development program for Haskell
tomjakubowski·Jan 2, 2016
> That being said very few C++ IDE's have advanced refactoring due to the scourge that is the C Preprocessor. This also why most people, like myself, stick with Vim for C/C++ development. C and C++ exploration and refactoring tools like rtags that hook directly into a compiler, and integrate with your editor of choice, have never failed me. I haven't put them up against too much in the way of preprocessor macro hell, but I've got to think they've got the best shot at doing "the right thing" in the face of macros. Just as a random example, see this https://github.com/Andersbakken/rtags/issues/281
In Yavide, a Modern C/C++ IDE

Showing the 15 most recent of 23 sources. Enable JavaScript to search and browse every indexed mention.

MAKE YOURSELF AT HOME

A few shortcuts

/
Search the collection
?
Open this guide
Esc
Close dialogs and navigation

Your saved repositories and interests stay in this browser.