New OnBoard is here — AI-guided, self-hosted onboarding for your codebase. Learn more

Free trial Get Understand

Features Code Navigation Static Analysis Graphs Compliance Metrics Custom API How it works FAQs Pricing Docs Start free trial

Features & capabilities

Everything you need to understand your code.

From architecture and dependency graphs to code metrics, navigation, and standards checking, Understand brings the tools you need to explore, analyze, and improve your codebase into one application.

Start free trial Jump to the full reference

20+

Languages parsed

120+

Graph types

100+

Metrics

1,000+

Static analysis checks

Core capabilities

Powerful tools for every part of code analysis.

Explore six of Understand’s core capabilities, from visualizing complex architectures and navigating code to measuring quality and checking compliance.

A butterfly graph in Understand: the selected function in the centre, its callers and callees joined to it by arrows.

Hover to play

Code Visualization

Understanding complex code relationships

Over 120 graph types generated from the parsed database — call trees, control flow, dependencies, UML, data flow. Every node is clickable, every graph exports.

Explore Code Visualization 15 features

Understand’s CodeCheck configuration: the list of built-in standards open, with MISRA, CERT and the rest shown.

Hover to play

CodeCheck

Enforcing standards and compliance

MISRA, AUTOSAR, CERT, JPL and your own rules, run on the desktop or in CI, with deviations recorded and reports an auditor will accept.

Explore CodeCheck 15 features

Understand showing a hover preview of a function: its parameters, return type and a plain-language summary.

Hover to play

Code Navigation

Developer productivity and code comprehension

Resolved uses, declarations and definitions for every entity. Not grep — the parser knows which of the four init() functions you meant.

Explore Code Navigation 6 features

A metrics treemap of an Understand project: each file sized by its line count and shaded by its maximum cyclomatic complexity.

Hover to play

Code Metrics

Measuring complexity and identifying problem areas

Complexity, size, coupling, cohesion and maintainability at project, architecture, file, class and function scope. Export any of it.

Explore Code Metrics 14 features

A dependency graph of custom architecture nodes in Understand: Core Server with arrows out to Modules, OS Abstraction and Public API Headers.

Hover to play

Architecture & Dependencies

Understanding system structure and managing technical debt

Group files into the subsystems your team actually uses, then trace dependencies between them and drill from a single arrow down to the references behind it.

Explore Architecture & Dependencies 5 features

Understand’s built-in AI answering a question about a function, with its location, signature and purpose.

Hover to play

AI-Powered Code Analysis

Faster code comprehension with AI grounded in static analysis

Ask what a subsystem does or what a change breaks, and get an answer tied to real entities from the parsed database rather than a guess from a text window.

See the features 4 features

Reference

Find the exact feature

Search by name, or pick a section. Everything on this list ships in the standard product.

Graphs & visualization

Graphs page

Over 120 graph types generated from the parsed database, not from comments.

Call graph: Everything a function calls, to any depth.
Called-by graph: Every path that reaches a function.
Butterfly graph: Callers and callees of one entity, side by side.
Control flow graph: Branches, loops and exits inside a single function.
Declaration graph: What a type or object is built from.
Dependency graph: File, directory and architecture level dependencies.
UML class diagram: Inheritance and composition, generated from source.
Object reference graph: Which code touches a given object.
Data flow graph: Where a variable is set and where that value travels.
Include graph: The real include tree, transitive includes included.
Cluster call graph: Call relationships collapsed by file or directory.
Metrics treemap: Size and complexity across the whole project at a glance.
Graph filters & legends: Hide noise, pin nodes, change depth, keep the layout.
Graph export (PNG, SVG, DOT): Drop a diagram straight into a review or a report.
Custom graph plugins: Write your own graph type against the Python API.

CodeCheck & standards

CodeCheck page

Published coding standards plus your own rules, run on the desktop or in CI.

MISRA C:2012: Including Amendments 1–4.
MISRA C:2023: The current C guideline set.
MISRA C++:2008: Legacy C++ guideline set, still required on many programs.
MISRA C++:2023: The current C++ guideline set.
AUTOSAR C++14: Automotive C++ coding guidelines.
CERT C / C++: Secure coding rules and recommendations.
CWE coverage: Checks mapped to common weakness categories.
JPL C standard: Flight-software rule set.
HIS metrics thresholds: Metric limits enforced as pass/fail checks.
Custom checks (Python): Your house rules, written against the same API.
Configurable rule sets: Per-project profiles, per-rule severity and options.
Inline violation markers: Violations shown on the line that caused them.
Deviations & suppressions: Record a justification, keep it with the project.
CodeCheck reports: HTML and CSV output an auditor can read.
Command-line CodeCheck runs: Fail a build on new violations.

Metrics

Metrics page

Complexity, size, coupling and maintainability at every scope in the project.

Cyclomatic complexity: Standard, modified and strict variants.
Essential complexity: How much structure survives after reducible logic is collapsed.
Halstead metrics: Volume, difficulty, effort and the rest of the set.
Maintainability index: A composite score per file or function.
Lines of code: Total, source, comment and blank, counted consistently.
Comment-to-code ratio: Per function, class, file or architecture.
Coupling (fan-in / fan-out): What depends on this, and what this depends on.
Class cohesion (LCOM): Whether a class is really doing one job.
Depth of inheritance: How far down a hierarchy a class sits.
Max nesting depth: The deepest block nesting in a function.
Knots & essential knots: Crossing control paths, a classic legacy-code smell.
Custom metrics plugins: Define and chart a metric Understand doesn't ship.
Metrics export (CSV): Straight into a spreadsheet or a dashboard.
Per-scope metric browser: Project, architecture, file, class and function scopes.

AI

Grounded answers about your code, backed by the Understand database.

Grounded code Q&A: Answers that cite entities from the parsed database.
Entity explanations: Plain-language summary of a function, class or file.
AI-assisted search: Describe what you're looking for instead of guessing a symbol.
Database context export: Feed accurate project structure to your own tooling.

Cross-references

Code navigation

Every use, declaration and definition resolved by the parser.

Hyper-xref (uses / used by): Resolved references, not a text search.
Jump to declaration: Declaration and definition, separately.
Call / called-by tree: Expandable textual tree beside the graph view.
Unused entity detection: Find code nothing reaches.
Entity filter & search: Filter by kind, language, file or name pattern.
Information browser: Everything known about one entity, in one panel.

Architectures

Architectures page

Group the project your way, then measure and enforce the grouping.

Custom architectures: Group files into subsystems that match your org, not your folders.
Architecture dependencies: See and drill into cross-subsystem coupling.
Architecture metrics: Roll every metric up to the subsystem level.
Dependency drill-down: From a single arrow to the exact references behind it.
Architecture reports: Export the structure and its numbers.

Editor & navigation

Read, search, compare and refactor without leaving the database.

Syntax-aware editor: Edit in place with full cross-reference context.
Project-wide search: Literal and regular-expression search across the database.
Compare files & databases: Diff two versions of a project, not just two files.
Annotations: Notes attached to entities, shared with the team.
Bookmarks & history: Retrace how you got somewhere.
Rename refactoring: Rename an entity across every resolved reference.

APIs & automation

Custom API page

Script anything the UI can do, headless.

Python API: Full read access to entities, references, metrics and graphs.
Perl API: The original scripting interface, still supported.
und command line: Create, configure and analyze a database from a script.
upython / uperl: Interpreters pre-wired to the Understand modules.
Headless analysis: No display required — build on a server.
Plugin framework: Ship checks, metrics, graphs and commands as plugins.
Scheduled re-analysis: Keep a database current against a moving branch.

Integrations

IDEs, build servers and version control.

Visual Studio: Open the current symbol in Understand.
Visual Studio Code: Cross-references and graphs from the editor.
Eclipse: Launch Understand in context.
Jenkins & CI servers: Run checks and metrics on every build.
Git & Subversion: Analyze a working copy or a specific revision.
Floating & air-gapped licensing: Including networks with no outbound access.

Languages

Supported languages

Dedicated parsers, including ones nobody else still supports.

C / C++: Including modern standards and vendor extensions.
C#
Java
Python
Ada: Ada 83, 95, 2005 and 2012.
Fortran: FORTRAN 77 through modern Fortran.
JOVIAL: Still flying, still supported.
Pascal / Delphi
PL/M
VHDL
Assembly: Common embedded targets.
Web languages: HTML, CSS, JavaScript and PHP.
Objective-C
COBOL

Reports & export

Custom reports

Get the evidence out in a form an auditor accepts.

HTML project reports: A browsable snapshot of the whole analysis.
Interactive reports: Over a hundred built-in report views.
CSV & XML export: For dashboards, spreadsheets and audit packages.
Graph image export: Diagrams sized for documents and slides.
Certification evidence: Qualification material for certified toolchains.

Evaluate it yourself

The trial is the full product — every parser, every check, no feature gates.

Start free trial

Bring us your program

Certification, legacy migration, IV&V — we have probably seen your situation before.

Talk to an engineer