a cross-­platform source explorer for C/C++

The machine is, and always will be, the court of last resort on documentation disputes. In the past, however, the machine has been a rather uncommunicative documenter. In order to rely more on the machine itself, we must use more imagination in getting the machine to tell its story in as many alternative ways a possible.

Gerald M. Weinberg –­ The Psychology of Computer Programming (1971)

Why Coati?

Software engineering is broken.

We are software engineers. We like building stuff. We like solving hard problems with smart algorithms and designing architectures that are modular and reusable. In a sense, we know that we have the skills and capacity to actualize all of our ideas. But sometimes, it’s more difficult than we expect. Professional software development is, more often than not, a team effort. Working in teams allows us to build better software and solve even harder problems, but it comes at a cost. When a codebase grows, it becomes increasingly complex and harder to track every addition. Consequently, more and more time is spent investigating the current implementation while less is spent on writing exciting new features. Often times developers who are new to a a project will have to spend weeks to months familiarizing themselves with the codebase before actually becoming productive.

Programming languages are not the problem.

Programming languages are constantly evolving. They reduce the overhead a software developer needs to keep in mind by abstracting away more and more limitations of the machine. But regardless of the language, if a project reaches a certain size, it's hard to keep a consistent mental model of the source code's structure. The problem here is not the poor abstraction of the language, but the high information density of code. Every line in the source code has a purpose and as a software developer, you spend most of your time searching for those small pieces that are relevant. Why can't we see how the components connect with each other, without constantly looking at every detail of code? Why can’t we take a step back and see code from a bird’s-eye-view? Seeing which objects are involved in a feature and the paths that it takes through the source files should be a no-brainer.

We have enough code editors.

When it comes to writing code, developers have a multitude of options to suit whatever workflow they desire. What is harder to address is how efficiently and thoroughly can we understand existing implementation, without wasting so much time. While there are many great code editors out there, they’re designed for writing code and are not made for navigating all implementation at hand. Sure, every developer has their strategy of finding information for their source code, from searching documentation to looking at tests, or even asking the original authors. But sometimes thorough documentation is impossible to find. The same goes for tests. And having the original authors readily available to answer all your questions is not realistic. What frequently ends up happening is the arduous task of taking pen to paper and making notes. This is neither the best solution nor the most engaging. When you’ve exhausted all your tools and energy, you will inevitably have a lot questions about the codebase with little to no sufficient answers or explanations. So let’s face it—nobody likes reading code and it’s a subject that programmers would rather avoid. Understanding the fundamentals of your codebase shouldn’t be that hard.

The computer knows it all!

The funny thing about all this? Your computer knows it all. That’s right! By using a compiler or interpreter, your computer already knows how the language works. It knows what paradigms exist and because it's turning your source code into executable instructions; it knows every single piece of information within the entire codebase including: where functions are called, how types get instantiated, where variables get changed. Accessing this information was not easily possible so far, but we ask: Why is it so hard? Our answer—it’s not.

Meet Coati!

We want you to meet Coati, the interactive source explorer that revolutionizes the way you think about code. Made by programmers for programmers, Coati is specifically crafted for easy navigation within your source code. It introduces a whole new concept of searching and understanding source code, by utilizing static analysis, visualization, and smart code search. Instead of looking at individual files, Coati treats your source code like an interrelated graph structure. It analyzes your code and saves all the information that relates to how the different symbols are composed and how they play together. By giving you easy access to all this information, Coati leaves you with more time to spend on things that you actually enjoy doing as a software developer.

How It Works

Coati first analyzes your code and gathers data about its structure. It then provides you with a simple interface for exploring you code consisting of three main components: the search field, the graph visualization and the code view. These three components are linked together, meaning that interactions in one view also change the content of the others.

Coati interface mockup explaining the basic concept

# Search

Use Coati's search field to enter search requests. The autocompletion box will instantly provide an overview of all matching results throughout your codebase. Once you complete your search request, the graph visualization will display the symbol's relationships to other symbols and the code view shows you all locations of that symbol within the source files.

# Code

The code view displays all source locations of the currently selected symbol in a list of code snippets. The snippets are grouped together by file and include the definition of the selected symbol and all its uses throughout the codebase. Clicking on a different source location allows you to dig deeper and consequently also updates the selection in the graph visual.

# Graph

The graph visualization displays the structure of your source code. It focuses on the currently selected symbol and directly shows all incoming and outgoing dependencies to other symbols. The nodes and edges of the graph can be selected to change the focus. Classes can be expanded to reveal all their members.

Explore Classes Visually Explore Classes Visually
Find Symbols with Fuzzy Search Find Symbols with Fuzzy Search
View all References of a Symbol View all References of a Symbol
Follow Calls in Graph or Code Follow Calls in Graph or Code
Investigate File Dependencies Investigate File Dependencies
Easy Project Setup Easy Project Setup
Switch Colors and Layout Switch Colors and Layout

The Best Parts

  • Accelerate your productivity by navigating and understanding source code faster.
  • Easily keep pace with a growing codebase by quickly familiarizing yourself with new additions.
  • The lightweight interface is easy to understand and let's you immediately get down to the real problem.
  • Coati is a standalone application that runs on all major platforms. Try it yourself!
  • It communicates with different code editors for seamless integration into your workflow.
  • It works out of the box with minimal setup involved.
  • It is secure to use with any source code by working completely offline.
  • It currently supports the programming languages C and C++.

Get Started!

Start using Coati now! Download our free trial or purchase the full version.

Keep updated about new features and releases by joining our mailing list. *powered by MailChimp

Sign up to our mailing list:

or follow us on social media