Glossary

Core Understand terms, each linked to the page that covers it in depth. Terms are listed alphabetically.

AI Overview

A plain-language, AI-generated description of a selected entity (function, class, file, …), shown in its own panel. See Understand AI — overview & setup.

Analysis error

A problem Understand hit while parsing — a header it couldn't find, an undefined macro, a construct it couldn't resolve. Analysis errors don't stop the database being built, but they leave entities and references missing, so accuracy work starts here. See Fix parse errors.

Annotation

A note — comment, to-do, task assignment, whiteboard image, or linked document — attached to an entity, file, or line without editing the source code. Annotations live with the project. See Annotate & share notes.

Architecture

An abstract, named hierarchy layered over your source — a virtual grouping of files and entities that you define, independent of the folders they live in. See What is an architecture?.

Baseline

A recorded set of the violations that already exist in a codebase, so CodeCheck flags only new violations going forward — a quality ratchet for legacy code. See Baseline existing violations.

Browse Mode

An editor mode that turns entities in the source into clickable links, so you navigate code the way you'd click through web pages. See Navigate with Browse Mode.

Buildspy

A tool that runs (or wraps) your compiler during a build and records the exact files, include paths, and macros it uses, giving Understand a project that matches what you actually compile. Compare with the Build Watcher in Capture your build.

Build Watcher

Understand's built-in build-capture mechanism — the same idea as Buildspy, integrated into the app. See Build Watcher vs Buildspy.

CodeCheck

Understand's static-analysis engine that verifies code against published or custom coding standards, naming rules, and metric thresholds. See What is CodeCheck?.

Comparison project

A second analyzed version of the same codebase, attached to the current project so Understand can report what changed between them — churn metrics, changed-code graphs, and the Changes Treemap. See Compare two project versions.

Cyclomatic Complexity

A metric counting the linearly independent paths through a function — a proxy for how hard it is to test and maintain. See What does Cyclomatic Complexity mean?.

Dependency

A reference that crosses from one group of entities into another (grouping follows each entity's parent chain). Dependencies are how Understand knows what depends on what. See What are dependencies?.

Entity

Anything Understand has information about — a file, class, function, variable, and so on. Entities and references are the foundation of everything Understand knows. See Read the Information Browser.

Fuzzy parse

The lighter-weight C/C++ parsing mode (UseStrict Off) that tolerates incomplete build information at the cost of some accuracy. Compare with Strict parse in Create an accurate C/C++ project.

Graph

A generated diagram of a relationship Understand already knows about — calls, control flow, inheritance, data flow, dependencies. Graphs are produced per entity or architecture, not drawn by hand, so they always reflect the current analysis. See Which graph should I use?.

Heatmap

A view that shades files or functions by a metric so outliers stand out at a glance — the fastest way to find where risk concentrates. See Find risky, complex code.

Home dashboard

The project overview shown when you open a project: parse accuracy, letter-graded complexity and technical debt, and the largest and most complex entities. See Read the Home dashboard.

Information Browser (IB)

The panel that shows just about everything Understand knows about the selected entity and lets you walk its relationships as an expandable tree. See Read the Information Browser.

Inspection

A single CodeCheck run — a snapshot of your code's conformance to a configuration at that moment. You can keep several inspections and configurations. See What is CodeCheck?.

Interactive Report

A report generated on demand for whatever you right-click — an entity, a file, an architecture, or the whole project — as opposed to a batch report run across the project. Interactive reports are Python plugins, so you can write your own. See What is a report?.

Kind

The type classification Understand assigns to every entity and reference (e.g. C Function, C++ Class). Kind-filter strings (like "function ~unresolved") select entities in filters, the API, and plugins. See Python API tutorial 3: entities, references, and filters.

Metric

A measured quantity about your code — size, complexity, coupling, cohesion, and more (e.g. CountLineCode, CyclomaticComplexity). See What metrics does Understand have?.

MCP (Model Context Protocol)

An open protocol that lets an external AI agent (Claude Code, Cursor, VS Code) query Understand's analysis through the shipped undmcp server, so the agent gets exact answers about your code. See Connect an AI agent via MCP.

Named Root

A symbolic name (e.g. SRC) mapped to a directory that can differ per machine, so a shared or CI project resolves its source wherever it is checked out. See Portable projects & Named Roots.

Plugin

A user script (Python .upy or Perl .upl) that adds a graph, architecture, metric, CodeCheck check, interactive report, Git, Shared Tasks and Project Quality Solutions. These are managed from the Plugin Manager. See Install & run plugins.

Portable project

A .und project set up (via Named Roots and relative paths) to resolve source across machines and build agents. See Portable projects & Named Roots.

Project (.und)

Everything Understand knows about one codebase: the file list, language and parse settings, and the database built by analysis. On disk it is a folder named <project>.und, not a single file. See Manage the .und database.

Reference

A place in the code that connects two entities — function A calls function B, a class declares a member, a file includes another. References are what Understand builds dependencies from. See What are dependencies?.

Strict parse

The default C/C++ parsing mode (UseStrict On) that uses Clang for compiler-accurate analysis, given correct include paths and macros. Compare with Fuzzy parse in Create an accurate C/C++ project.

Treemap

A view that tiles the codebase as nested rectangles sized by one metric and coloured by another, so you can see where the mass and the risk sit at once. The Changes Treemap variant colours by churn between two project versions. See Find risky, complex code and The Changes Treemap.

und (CLI)

The und command-line tool that creates and updates projects and automates analysis, metrics, reports, and CodeCheck — headless, ideal for CI. See Run Understand from the command line.

Violation

An instance where your code breaks a CodeCheck rule, reported in the Violation Browser (distinct from analysis errors). See View & triage violations.

Virtual Debugger

A tool for stepping through a function's logic by hand, without running the code — you make the branch decisions and it records the path. See Trace logic with the Virtual Debugger.