Qt Creator Manual

Acknowledgements

Credits

Third-party Components

Activate custom output parsers

Activate kits for a project

Manage kits

Copy custom settings from vanished targets

Add CMake tools

Add or remove CMake tools

Set the default CMake tool

Add CMake tools to kits

Add Nim compilers

Add Qt versions

Register installed Qt versions

Set up new Qt versions

Register documentation

Troubleshoot Qt installations

Minimum requirements

Add a Java language server

Add a license header template for C++ code

Add bookmarks to help pages

Import and export bookmarks

Add code snippets to the auto-complete menu

Add compilers

Re-detect compilers

Add C or C++ compilers

Supported compilers

Bare-metal compilers

Troubleshoot MinGW compilation errors

Add custom compilers

Add custom output parsers

Set custom parser preferences

Add debuggers

Remove debuggers

Add external documentation

Add generic language servers

Add kits

Set the default kit

Add libraries to CMake projects

Add your own libraries

Add external libraries

Use local CMake Find packages

Add libraries to qmake projects

Library location

Target platform

Linking

Development platform

Add subprojects to projects

CMake projects

qmake projects

Add subprojects to the root project

Remove subprojects

Specify dependencies

Add tests to existing test projects

Add translation files

Add wizards

Adding Docker Devices

Adding Docker Images as Devices

Selecting Docker Images

Modifying Entry Points

Specifying Paths to Mount

Auto-detecting Kit Items

Editing Docker Device Kits

Adding Qt Designer Plugins

Locating Qt Designer Plugins

Matching Build Keys

Adding an Internal Library to a qmake Project

Creating a shared library

Linking an application to the library

AdoptOpenJDK

All Topics

Analyze code with Clang-Tidy and Clazy

Analyze the current file

Analyze an open project

View diagnostics

Disable checks

Load diagnostics from YAML files

Analyzing CPU Usage

Using the Performance Analyzer

Profiling Memory Usage on Devices

Specifying Performance Analyzer Settings

Choosing Event Types

Choosing a Sampling Mode and Period

Selecting Call Graph Mode

Setting Stack Snapshot Size

Adding Command-Line Options for Perf

Resolving Names for JIT-compiled JavaScript Functions

Analyzing Collected Data

Selecting Event Ranges

Understanding the Data

Viewing Statistics

Visualizing Statistics as Flame Graphs

Interaction between the views

Loading Perf Data Files

Loading and Saving Trace Files

Troubleshooting

Analyzing Code

Analyzing Code with Cppcheck

Running Cppcheck on Selected Files

Android Application Fundamentals

Android NDK

Android OpenSSL support

Android Run Settings

am Start Options

Shell Commands

Android SDK Command-line Tools

Android Studio Installation Guide

Application Output

Application Output Preferences

Apply quick fixes

Create functions

Implement member functions

Insert virtual functions

Create getters and setters

Generate constructors

Assign keyboard shortcuts

Record key sequences

Automatically format QML/JS files

Autotools

Working with Autotools Projects

Axivion

Bazaar

Uncommitting Revisions

Bazaar Preferences

Beautifier

Beautifier Tool Options

Using a Predefined ClangFormat Style

Defining a Style

Beautify source code

Format the currently open file

Format at cursor with ClangFormat

Format selected text with Uncrustify

Behavior

Specifying Tab Settings

Specifying Tabs and Indentation

Setting Typing Preferences

Bookmark code

Add notes to bookmarks

Navigate bookmarks

Locate bookmarks

View bookmarks

Boot2Qt Run Settings

Build and run tests

Select tests to run

Run and debug tests from code editor

Turn on build system based tests

Locate Qt Test data tags

Build for many platforms

Build an application

Cancel builds

Build projects in several configurations

Build files or subprojects

Remove build artifacts

Building Applications for the Web

Requirements

Setting Up the Development Environment

Setting Up Qt for WebAssembly

Specifying WebAssembly Settings

Adding WebAssembly Kits

Running Applications in a Web Browser

Building and Running an Example

C++ Code Style

Using Built-In Indenter

Specifying Settings for Content

Specifying Settings for Braces

Specifying Settings for Switch Statements

Specifying Alignment

Binding Pointers and References

Creating ClangFormat Files from Command Line

C++ Quick Fixes

CMake

Supported CMake Versions

CMake Build Configuration

Initial Configuration

Current Configuration

Multi-Config Support

Modifying Variable Values

Adding Variables

Changing Variable Values

Removing Variables

Viewing Advanced Variables

Re-configuring with Initial Variables

Viewing CMake Output

CLICOLOR_FORCE Environment Variable

Using Junction Points on Windows

CMake Build Steps

Using Ninja as a CMake Generator

Using CMake with Package Managers

QTC_RUN Environment Variable

CMake Clean Steps

CMake Lexer

CMake Presets

Configure Presets

MinGW Example

Ninja Generator Example

MSVC Example

Using Conditions

CMake: CMAKE_EXPORT_COMPILE_COMMANDS

CMake: CMAKE_OSX_DEPLOYMENT_TARGET

CMake: Find Modules

CMake: HEADER_FILE_ONLY

CMake: add_executable command

CMake: cmake(1)

CMake: cmake-packages(7)

CMake: cmake-variables(7)

CMake: find_package command

CMake: install command

CMake: set_property command

CMake: set_source_files_properties command

CMake: target_compile_definitions command

CMake: target_link_libraries command

CMake: target_sources command

CVS

CVS Preferences

Call Hierarchy

Change editor colors

Export and import color schemes

Change text encoding

Set default encoding

Check code syntax

Examples of C++ code errors

Check QML or JavaScript syntax

Manage messages

Set line annotation positions

Checking Code Coverage

Configuring Coco

Changing Fonts and Colors

Clang Code Model

About the Clang Code Model

Clangd Indexing

Clang Tools

Clangd

Clang Checks

Class View

Clazy

ClearCase

Using GNU Diffutils with ClearCase

Checking out and Checking in

Code Model

Inspect preprocessed C++ code

Collect usage statistics

Specify telemetry settings

Command-Line Options

Using Custom Styles

Compare files

View unsaved changes

Compare two files

View changes

Revert and apply changes

Reload files

Paste changes for review

Change colors

Compile Output

Compile Output Preferences

Parsing Existing Compile Output

Compilers

Complete CMake code

Complete code

Summary of Available Types

Complete code snippets

Completion

Code Completion Behavior

Automatically Inserting Matching Characters

Conan Build Configuration

Conan Package Manager

Configure Clang diagnostics

Suppressing Diagnostics

Selecting Clazy Check Levels

Creating Clang-Tidy Configuration Files

Configure Python language servers

Configure language server workspace

Configure on-device developer options

Configure projects for building

Manage build configurations

Edit build configurations

Build on remote devices

Start external processes

Add build steps

Add custom build steps

Execute custom commands

Add clean steps

Configure projects for running

Manage run configurations

qmake run configurations

Select the default run target

CMake run targets

qmake run targets

Meson run targets

Configuring Projects

Specifying Build Settings

Specifying Run Settings

Overriding Global Preferences

Configuring Qt Creator

Checking Build and Run Settings

Changing Keyboard Shortcuts

Changing Color Schemes

Adding Your Own Code Snippets

Configuring Version Control Systems

Managing Plugins

Connecting Android Devices

Requirements

Specifying Android Device Settings

Manual Setup

Viewing Android Tool Chain Settings

Managing Android NDK Packages

Managing Android SDK Packages

Managing Android Virtual Devices (AVD)

Creating a New AVD

Debugging on Android Devices

Connecting Bare Metal Devices

Specifying Settings for Debug Server Providers

EBlink

J-Link

OpenOCD

St-Link

uVision IDE

uVision Simulator

uVision St-Link or JLink Debugger

Adding Bare Metal Devices

Building for and Running on Bare Metal Devices

Connecting Boot2Qt Devices

Enabling the Boot2Qt Plugin

Adding Boot2Qt Devices

Protecting Connections

Flashing Boot2Qt Devices

Configuring Connections

Connecting Devices

Connecting MCUs

Requirements

Setting Up the Development Environment

MCU Plugin

Specifying MCU Settings

Adding MCU Devices

Managing MCU Kits

Running Applications on MCUs

Supported Qt for MCUs SDKs

Connecting MCUs

Connecting QNX Devices

Adding a QNX Neutrino Device in Qt Creator

Add kits for QNX Devices

Connecting Remote Linux Devices

Configuring SSH Connections

Generating SSH Keys

Managing Device Processes

Connecting iOS Devices

iOS 17 Devices

Configuring Devices

Viewing Device Connection Status

Specifying Supported iOS Versions

Testing on Simulator

Managing Simulators

Contact Qt

Report bugs and suggest improvements

Give feedback

Join discussions

Converting UI Projects to Applications

Converting into qmake Projects

Handling Large Data Files

Adding Custom Fonts

Adding Qt Quick Designer Components to Qt Installations

Create Boost tests

Create C++ classes

Create CTest Based Tests

Create Catch2 tests

Create Google tests

Create Nimble projects

Create OpenGL fragment and vertex shaders

Create Qt Quick Applications

Create Qt Quick UI Prototypes

Create Qt Quick tests

Create Qt tests

Create UML-style models

Create scratch models

Create VCS repositories for new projects

Create class diagrams

Add relations

Specify members

Create compiler explorer sessions

Create component diagrams

Create files

Select file type

Create package diagrams

Create pixmaps from SVG images

Create resource files

Sort resource files

Set a path prefix

Set a locale

Remove resource files

Create state charts

Create vcpkg manifest files

Creating Optimized 3D Scenes

Creating Optimized 3D Scenes

Creating Projects

Creating a Mobile Application

Setting up the Development Environment

Creating the Project

Adding Images as Resources

Creating the Accelbubble Main View

Locking Device Orientation

Adding Dependencies

Running the Application

Creating a Qt Quick Application

Creating the Project

Deploying Applications

Creating Custom QML Types

Connecting Mouse Clicks to State Changes

Adding Page to the Main View

Animating Transitions

Creating a Qt Widget Based Application

Creating the Text Finder Project

Filling in the Missing Pieces

Designing the User Interface

Completing the Header File

Completing the Source File

Creating a Resource File

Adding Resources to Project File

Compiling and Running Your Application

Creating a Qt for Python Application with Qt Quick

Creating an Empty Project

Adding Qt Quick Imports

Adding a Main Function

Loading the QML File

Designing the UI

Adding Imports

Adding Properties and Functions

Adding Qt Quick Controls

Running the Application

Creating a Qt for Python Application with Qt Widgets

Creating an Empty Window Project

Adding Qt Widgets Imports

Adding a Widgets-Based UI

Adding Signals and Slots

Adding a Main Function

Instantiating the MainWindow Class

Executing the Qt Code

Running the Application

Custom Wizards

Wizard Types

Locating Wizards

Tips for Wizard Development

Mapping Actions to Keyboard Shortcuts

Verbose Output

Integrating Wizards into Builds

Using Variables in Wizards

Localizing Wizards

Creating Wizards

Values Available to the Wizard

Available Pages

Field Page

File Page

Form Page

Kits

Project

Summary

VcsCommand

VcsConfiguration

Available Widgets

Check Box

List

Label

Line Edit

Path Chooser

Spacer

Text Edit

Available Generators

File Generator

Scanner Generator

Customize the build process

Stop applications before building

Use jom

Debug CMake project files

Debug Mode Views

Managing Debug Views

Customizing Debug Views

Debugger Log

Directly Interacting with Native Debuggers

Debugger Preferences

Mapping Source Paths

Specifying GDB Settings

Extended GDB Settings

Specifying CDB Settings

Setting CDB Paths on Windows

Debugging

Debugging Qt Quick Projects

Setting Up QML Debugging

Debugging Qt Quick UI Projects

Debugging Qt Quick Applications

Using Default Values

Starting QML Debugging

Debugging JavaScript Functions

Inspecting Items

Inspecting User Interfaces

Executing JavaScript Expressions

Applying QML Changes at Runtime

Debugging a C++ Application

Debugging a Qt Quick Application

Deploying to Android

Packaging Applications

Specifying Deployment Settings

Specifying Settings for Packages

Selecting API Level

Building AABs

Signing Android Packages

Adding External Libraries

Editing Manifest Files

Package Names

Styling

Screen Orientation

Icons

Splash Screens

Setting Permissions

Deploying to Boot2Qt

Launching Applications on Boot

Deploying to Devices

Deploying to QNX Neutrino

Finding Configured Devices

Deploying to Remote Linux

Adding Missing Files

CMake Builds

qmake Builds

Deploy Steps

Uploading Files

Creating a Tarball

Designing a UI for Infineon Traveo II

Designing a UI for NXP i.MX RT1170

Designing a UI for Renesas RA6M3G

Designing a UI for Renesas RH850-D1M1A

Desktop Device Run Settings

Working Directory

Run in Terminal

Linker Libraries

Debugging Linked Frameworks

Running as root User

Desktop Platforms

Linux

macOS

Windows

Compiling from Source

Detach the help window

Detach views

Attach views

Revert changes

Detecting Memory Leaks with Heob

Specifying Heob Settings

Recording Results

Handling Exceptions

Raising Exceptions on Errors

Protecting Pages

Handling Leak Data

Detecting Memory Leaks with Memcheck

Selecting Options for Memory Analysis

Showing Reachable and Indirectly Lost Blocks

Suppressing Errors

Develop Qt for Python applications

Set up PySide6

Create Qt for Python applications

Select the Python version

Create kits for Python

Use Python interactive shell

Developing with Qt Creator

Managing Projects

Designing User Interfaces

Editing Code

Semantic Highlighting

Finding

Refactoring Code

Configuring the Text Editor

Building, Deploying, and Running Applications

On Devices

Previewing QML

Debugging Applications

Analyzing Source Code

Running Tests

Publishing Applications

Qt Tools

Document code

Download Android Studio

Download OpenJDK

Download highlight definitions

Remember preferred definitions

Download definitions

Ignore file patterns

Add your own definitions

Edit CMake configuration files

Edit MIME types

Change predefined MIME types

Change default editor for a file type

Add magic headers

Reset MIME types

Edit Markdown files

Format text

Move to a line and column

Follow links to web sites

Edit Mode

Editing Code

Navigating Code

Editor Toolbar

Adding Space Around Toolbar Items

Resizing Views

Copying File Information

Editing Selected Lines

Edit Qbs profiles

Edit environment settings

Edit like in Vim

Escape FakeVim mode

Quit FakeVim mode

Edit properties of QML types

Preview images

Format text

Preview animations

Edit rectangles

Show toolbars immediately

Pin toolbars

Edit vcpkg manifest files

Add packages to manage

Generate code for CMake configuration files

Set the path to vcpkg

Embedded Platforms

Bare Metal

Boot2Qt

Remote Linux

Microcontroller Units (MCU)

QNX

Enable and disable plugins

Enable debugging

Enclose code in brackets or quotes

Evaluating Expressions

Adding Expression Evaluators

Expressions View Actions

JavaScript Expressions

C and C++ Expressions

Examining Data

Showing Tooltips for Simple Values

Examining Complex Values in Debug Views

Stepping Through Code

Compressing Steps in GDB

Stepping into Frameworks in macOS

Inspecting Basic Qt Objects

Changing Value Display format

Changing Variable Values

Signal-Slot Connections

Low-level Data

Exclude files from to-do lists

Executing C++ Before QML Tests

Explore compiler code

Set compiler options

FAQ

General Questions

Qt Designer Integration Questions

QML and Qt Quick Questions

Help Questions

Debugger Questions

Compiler Questions

Qt Installation Questions

Platform Related Questions

Questions about New Features

FakeVim

Setting Vim Behavior

Emulating Plugins

Mapping FakeVim Commands

Mapping User Commands

FakeVim Modes and Commands

Normal and Visual Modes

Command-Line Mode

Insert Mode

Options

Vimrc Example

File System

File System Context Menu

File System View Toolbar

Filter documentation

Add filters

Change filters

Remove filters

Find information in Qt documentation

Help mode sidebar views

Find keyboard shortcuts

Find preferences

Sort preference categories

Filter preferences

Go to tabs in Preferences

Find settings files

Find symbols

Find references to a symbol

Color-code access type

Find symbols that match search criteria

View found symbols

Font & Colors

Configuring Fonts

Format CMake files

Fossil

Configuring Fossil

Additional Fossil Functions

Fossil Preferences

Get help

Change the font

Return to the editor

Select help viewer backend

View function tooltips

Getting Started

Getting Started on NXP

Getting Started on Renesas

Getting Started on STM

Getting Started on Windows

Git

Using Git for Windows

Initializing Git Repositories

Working with the Current File

Viewing Git Diff

Viewing Git Log

Viewing Annotations

Staging Changes

Resetting Changes

Working with the Current Project

Cleaning Projects

Working with Local Repositories

Viewing Reference Log

Viewing Git Status

Committing Changes to Git

Amending Commits

Resetting Local Repository

Working with Branches

Adding Branches

Managing Branches

Configuring Merge Tools

Applying Patches

Using Stashes

Applying Actions to Commits

Working with Remote Repositories

Managing Remote Repositories

Using Git with Subversion

Reviewing Code with Gerrit

Working with Git Tools

GitLab

Connecting to GitLab Servers

Cloning Projects

Glossary

Gumbo, version 0.10.1

Highlight code blocks

Fold code blocks

Fold all comment blocks

Animate matching braces

Move between code blocks

How To

Analyze

Build and Run

Build with CMake

Build with qmake

Run applications

Create Models and Diagrams

Debug

Design UIs

Edit Code

Configure Editors

Manage Language Servers

Search

Manage Kits

Manage Projects

Create Projects

Add Files

Configure Projects

Read Documentation

Test

Use Qt Creator

Use the UI

Import an existing project

Specify files

Use a script

Precompiled headers

Specify include paths and framework paths

Specify defines

Forward flags to Clang code model

Provide deployment information

Create a run configuration

Import and export keyboard shortcuts

Include Hierarchy

IncrediBuild

IncrediBuild Build Configuration

IncrediBuild Build Steps

Distribution Control Settings on Linux

Distribution Control Settings on Windows

IncrediBuild Clean Steps

Indent text or code

Automatically fix indentation

Show whitespace in editor

Display right margin

Infineon Traveo II quick start guide

Insert multiple cursors

Inspect internal logs

View logs

Inspect language clients

Check language server capabilities

Inspect memory usage

Inspect the code model

Install Qt Creator

Qt Online Installer

Standalone Qt Creator

Use package managers

Download installation packages

Build from sources

Install plugins

Issues

JSON for Modern C++, version 3.11.2

JavaScript and QML Checks

Enabling and Disabling Messages

JavaScript and QML Error Codes

Resetting the Code Model

KSyntaxHighlighting, version v5.103.0

KSyntaxHighlighting: alert.xml

KSyntaxHighlighting: bash.xml

KSyntaxHighlighting: cmake.xml

KSyntaxHighlighting: css.xml

KSyntaxHighlighting: doxygen.xml

KSyntaxHighlighting: dtd.xml

KSyntaxHighlighting: html.xml

KSyntaxHighlighting: ini.xml

KSyntaxHighlighting: java.xml

KSyntaxHighlighting: javadoc.xml

KSyntaxHighlighting: json.xml

KSyntaxHighlighting: markdown.xml

KSyntaxHighlighting: modelines.xml

KSyntaxHighlighting: perl.xml

KSyntaxHighlighting: perl6.xml

KSyntaxHighlighting: powershell.xml

KSyntaxHighlighting: qdocconf.xml

KSyntaxHighlighting: ruby.xml

KSyntaxHighlighting: toml.xml

KSyntaxHighlighting: valgrind-suppression.xml

KSyntaxHighlighting: xml.xml

KSyntaxHighlighting: yacc.xml

KSyntaxHighlighting: yaml.xml

Keyboard Shortcuts

General Keyboard Shortcuts

Editing Keyboard Shortcuts

Emacs Shortcuts

Qt Designer Shortcuts

Image Viewer Shortcuts

Debugging Keyboard Shortcuts

Project Keyboard Shortcuts

Help Keyboard Shortcuts

Version Control Keyboard Shortcuts

Kits

Filtering Kit Preferences

Kit Preferences

Known Issues

General Issues

Editing Issues

Projects Issues

Debugging Issues

LLVM / Clang

LLVMPipe

Language Server Protocol

Language Servers

Adding MIME Types for Language Servers

Adding Language Servers

Supported Locator Filters

Reporting Issues

Launching the Debugger

Debugger Operating Modes

Start Internal

Start External

Attach

Attaching to Running Applications

Attaching to Processes when They Start

Core

Post-Mortem

Starting the Debugger from the Command Line

Link projects to Axivion dashboards

Link projects with GitLab

Local Variables and Function Parameters

Locals View Actions

Selecting Object Type for Display

Locate files using the keyboard

Locator

Changing Locator Filters

Adding Web Search Engines

Creating Locator Filters

Configuring Locator Cache

Manage data collection

Principles of data collection

Manage files in CMake projects

Manage sessions

Create new sessions

Open sessions

Open sessions from the locator

Mercurial

Mercurial Preferences

Meson

Adding Meson Tools

Editing Meson Build Descriptions

Code Completion and External Libraries

Current Meson Support Limitations

Meson Build Configuration

Meson Build Steps

Meson Clean Steps

Mobile Platforms

Android

iOS

Model Editor

Editing Models

Grouping Elements

Aligning Elements

Managing Elements

Zooming into Diagrams

Printing Diagrams

Exporting Diagrams as Images

Adding Custom Elements

Move between files

Locate files

Locate files from global file system index

Browse location history

Navigate with the keyboard

Move in QML code

Locate QML methods

Find QML types

Inspect QML and JavaScript

Move between QML and C++

Move to symbols

Locate symbols

Move to symbol definition or declaration

Follow symbols

Switch between function definition and decalaration

Open links in another split

Open resource files for editing

NXP i.MX RT1170 quick start guide

Navigate with locator

Go to the locator

Use locator filters

Use wildcard characters in search strings

Omit default filters

Locate lines and columns

Search the web

Create files and directories from the locator

Nim

Code Style

Tools

Nimble

Open Documents

Setting Preferences for Opening Files

Open Source Front-End for C++

Open Source Tool for Generating C++ Code That Classifies Keywords

Open projects

Re-configure projects

Import builds

Show progress information

OpenJDK

Optimizing Applications for Mobile Devices

Optimizing Designs

Outline

Overview - QML and C++ Integration

Parse files

Select parse context

Reparse externally changed files

Paste and fetch code snippets

Paste snippets

Fetch snippets

Set code pasting preferences

Set a shared network drive for code pasting

Paste text from clipboard history

Perforce

Configuring Perforce

Editing Files

Perform calculations

Built-in functions

Peripheral Registers

Prevent code erosion

View issue counts

Filter issues

Jump to issues in the editor

Previewing in Browsers

Previewing on Desktop

Previewing on Devices

Previewing on Android Devices

Previewing on Boot2Qt Devices

Profile CMake code

Profiling Function Execution

Building Apps for Profiling

Collecting Data

Viewing Collected Data

Selecting Profiling Options

Enabling Full Cache Simulation

Enabling Branch Prediction Simulation

Profiling QML Applications

Using QML Profiler

Specifying Flushing Settings

Attaching to Running Qt Quick Applications

Analyzing Collected Data

Selecting Event Ranges

Understanding the Data

Analyzing Scene Graph Events

Analyzing Qt Quick 3D Events

Viewing Statistics

Visualizing Statistics as Flame Graphs

Projects

Projects View Context Menu

Projects View Toolbar

Pty-Qt

Python Run Settings

Custom Executable Run Configuration

QML Import Path

QML Quick Fixes

QNX Run Settings

Qbs

Qbs

Building Qbs

Qbs

Qbs Build Configuration

Qbs Build Steps

Qbs Clean Steps

Qt Application Manager

Qt Creator Manual

Qt Design Studio Manual

Qt Designer

Code Editor Integration

Managing Image Resources

Specifying Settings for Qt Designer

Previewing Forms Using Device Profiles

Adding Device Profiles

Qt QR Code Generator Library

Qt Qml

Qt Quick Code Style

Qt Quick Designer

Opening Files in Qt Design Studio

Editing Files in Qt Quick Designer

Qt Quick UI Prototype Run Settings

Qt for MCUs

Qt for MCUs - All QML Types

Qt for MCUs - Supported Target Platforms

Qt for MCUs Known Issues or Limitations

Qt for MCUs documentation

QtKeychain

Quick Fixes

Function Locations

Function Names and Attributes

Namespace Handling

Custom Parameter Types

RSTParser

Read CMake documentation

Record screens

Set the screen and area to record

Edit recordings

Record text editing macros

Record macros

Play macros

Save macros

Assign keyboard shortcuts to macros

Reference

Analyzers

Build Systems

Build Configurations

Editors

Platforms

Preferences

Analyzer

C++

Kits

Text Editor

Run Configurations

UI Design

Views

Output Views

Sidebar Views

Remote Debugging

Using GDB

Using CDB

Remote Linux Run Settings

Rename symbols

Renesas EK-RA6M3G quick start guide

Renesas RH850-D1M1A quick start guide

Run Python applications

Run QML files

Run Qt Creator from the command line

Examples of CLI commands

Open a project from a directory

Run in Qt Application Manager

Application manager CMake functions

Customize the installation

Automatic deployment configuration selection

Deployment configuration

Installation settings

Application manager run settings

Profile Qt Quick applications

Run on QNX devices

Troubleshoot errors

Debug output cannot be shown

Cannot run, debug, or stop applications

Run on many platforms

Run applications

Run on mobile and embedded devices

Select run targets

Run without deploying

Run without building

Run on remote Linux devices

Run qmake before building

Running Valgrind Tools on External Applications

Running on Devices

SCXML Editor

Navigating State Charts

States

Adding States

Aligning and Editing States

Viewing State Tree Structure

Managing Transitions

Adding Executable Content

SQLite

Screen Recording

Search Results View

Viewing Search Results

Search Results View Toolbar

Search and replace using a regular expression

Search from documentation

Search in current file

Set search criteria

Replace text

Preserve case when replacing

Highlight search hits

Search globally

Search in projects or file systems

Search in all projects

Search in the file system

Search and replace

Select line ending style

Set default style

Select the build system

Migrate to another build system

Set preferences for building and running

Select the current code block

Turn on smart block selection

Select the help start page

Set C++ file naming preferences

Set high DPI scaling

Set the number of recent files shown

Set up version control systems

General VCS preferences

Setting Breakpoints

Unclaimed and Claimed Breakpoints

Adding Breakpoints

Specifying Breakpoint Settings

Moving Breakpoints

Deleting Breakpoints

Enabling and Disabling Breakpoints

Setting Data Breakpoints

Setting Up Debugger

Supported Native Debugger Versions

Supported GDB Versions

Supported CDB Versions

Supported LLDB Versions

GDB Run Modes

Installing Native Debuggers

GDB

Debugging Tools for Windows

Debugging Tools for macOS

LLDB

PDB

Setting up FSF GDB for macOS

Share project settings

Create a shared settings file

Update shared settings

Shellintegrations

Shellintegrations/Clink

Show and hide sidebars

Show and hide the main menu

Show task list files in issues

Manage task list entries

Task list file format

Snippets

Editing Snippets

Removing Snippets

Resetting Snippets

Source Code Pro Font

Specify Clang tools settings

Specify Valgrind settings for a project

Specify a custom executable to run

Specify clangd settings

Specify code style

Specify dependencies

Specify editor settings

Specify project contents

CMake Projects

qmake Projects

Specify settings for quick fixes

Specify the environment for projects

Globally change the environment

Change the environment for a project

Specify the build environment

Clear the build environment

Specify the run environment

Clean the run environment

Set the environment for all run configurations

Use device environment

Split the editor view

Move between views and windows

Remove splits

Start the emulator from the command line

Stopping Applications

Subversion

Subversion Preferences

Supported Platforms

Switch UI themes

Switch between modes

Switch to Edit mode

TartanLlama/expected

Technical Support

Terminal

Terminal Preferences

Test Results

Qt Test Output

Summary of Messages

Filtering Test Results

Blacklisting Tests

Testing

Qt Tests

Google Tests

Boost Tests

Catch2 Tests

Specifying Settings for Running CTest-Based Tests

To-Do

To-Do Entries

Troubleshooting Debugger

Cannot Launch Debugger

Debugger Does Not Hit Breakpoints

Debugger Does Not Work

Pointer Variable Members Are Not Displayed Directly

Structure Members Are Not Sorted According to Structure Layout

Built-in Debugger Is Slow During Startup and Runtime

Caching GDB Symbol Index

Minimizing Number of Breakpoints

Cleaning Builds

Disabling Incremental Linking

Debugger Cannot Attach to Running Process on Linux

Turn on QML Language Server

Turn on Silver Searcher

Set location of Silver Searcher

Tutorials

Type Hierarchy

UI Files

Supported Methods

JavaScript Functions

Qt QML Methods

Use GitHub Copilot

Requirements

Set Copilot preferences

Receive suggestions

Turn suggestions on and off

Use Qt Creator variables

Use Qt Linguist

Use lupdate and lrelease

Synchronize TS files

Generate QM files

Use common VCS functions

Add files

View diff output

View versioning history and change details

Annotate files

Commit changes

Revert changes

View status

Update the working tree

Delete files

Use compilation databases

Use external text editors

Use external tools

Configure external tools

Use project wizards

Select project type

Bind keyboard shortcuts to wizards

User Interface

What's New?

Using Debugging Helpers

Extending Debugging Helpers

Customizing Built-In Debugging Helpers

Adding Custom Debugging Helpers

Debugging Helper Overview

Debugging Helper Implementation

Dumper Class

Dumper.Type Class

Dumper.Field Class

Dumper.Value Class

Children and SubItem Class

Using QML Modules with Plugins

Generating Type Description Files

Dumping Plugins Automatically

Importing QML Modules

Using Squish

Specifying a Squish Server

Specifying AUTs

Mapping AUTs

Specifying AUT Paths

Adding Attachable AUTs

Managing Test Suites and Cases

Creating Test Suites

Recording Test Cases

Running Test Suites

Mapping Symbolic Names

Inspecting Local Variables

Specifying Settings for Running Tests

Viewing Test Results

Viewing Squish Runner and Server Logs

Using Valgrind Code Analysis Tools

Validating with Target Hardware

Version Control Systems

View CMake project contents

Re-configure CMake projects

Hide subfolder names in Projects view

View images

View output

Change text encoding

Find and filter output

Viewing Call Stack Trace

Loading QML Stack

Viewing Disassembled Code

Starting Disassembler

Viewing Modules

Breaking on Loading Modules in CDB

Viewing Source Files

External Sources

Viewing Threads

Viewing and Editing Register State

Examining Memory

Visualizing Chrome Trace Events

Opening JSON Files

Visualizing Events

Selecting Event Ranges

Viewing Statistics

Collecting LTTng Data

Configuring the Kernel

Installing LTTng

Building Qt with Tracepoints

Recording Events

Enabling Trace Points

Scheduler Switch Trace Points

Syscall Trace Points

Converting LTTng Data to CTF

What is API Level?

WinPty

Write down notes

YAML C++ Parser, version 0.8.0

avdmanager

cmake-format

conan.cmake

conan.cmake

libvterm

litehtml, version v0.9

qmake Build Configuration

Build Directory

Tooltips in Kit Selector

Separating Debug Info

Compiling QML

Parsing Project Contents

Global qmake Settings

qmake Build Steps

qt6_am_create_builtin_package

qt6_am_create_installable_package

sdk_definitions.json

sdkmanager

std::span Implementation for C++11 and Later

vcpkg Package Manager

Setting vcpkg Preferences