Qt Creator Documentation

Add Qt Widgets Designer Plugins

Locate Qt Widgets Designer plugins

Match build keys

Licenses and acknowledgments

Licenses

Credits

Third-party components

Add Docker devices

Select Docker images

Edit Docker device kits

Analyzing code

Using code analysis tools

Overview of the code analysis tools

Static analysis for C and C++

Axivion Suite

Clang-Tidy and Clazy

Cppcheck

QML and JavaScript

Static checks for QML and JavaScript

QML Profiler

Memory analysis

Valgrind

Heob

Profiling and tracing

Performance Analyzer

Chrome Trace Format Visualizer

Code coverage

Coco

Local analysis with Axivion

Local dashboard

Single file analysis

View Axivion static code analysis results

View inline annotations in editor

View issues

Sort issues

Issue types

Filter issues

Jump to issues in the editor

Beautify source code

Format the currently open file

Format at cursor with ClangFormat

Format selected text with Uncrustify

Setting breakpoints

Unclaimed and claimed breakpoints

Specify dependencies

Tutorial: Build and run

{Building and Running an Example}

Customize the build process

Stop applications before building

Use jom

CMake Qt Creator vendor presets

CMake configuration presets

Compiler presets

Debugger presets

Qt version presets

CMake presets

Configure presets

MinGW example

Ninja generator example

MSVC example

Cross-compilation example

Using conditions

Test presets

Building projects with CMake

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

CMake build steps

Using Ninja as a CMake generator

Using CMake with package managers

QTC_RUN environment variable

CMake clean steps

Conan build configuration

IncrediBuild build configuration

IncrediBuild Build Steps

Distribution control settings on Linux

Distribution control settings on Windows

IncrediBuild Clean Steps

Meson build configuration

Meson Build Steps

Meson Clean Steps

Qbs build configuration

Separating debug info

Compiling QML

Qbs Build Steps

Qbs Clean Steps

Building projects with qmake

Build directory

Tooltips in kit selector

Separating debug info

Compiling QML

Parsing project contents

Global qmake settings

qmake build steps

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

Specify build and run settings

Build for many platforms

Build an application

Cancel builds

Build projects in several configurations

Build files or subprojects

Remove build artifacts

Profile function execution

Build apps for profiling

Collect data

View collected data

View call hierarchy

{Call Hierarchy}

Check code syntax

Examples of C++ code errors

Check QML or JavaScript syntax

Manage messages

Set line annotation positions

Clang code model

About the Clang code model

Clangd indexing

Analyze code with Clang-Tidy and Clazy

Analyze the current file

Analyze an open project

View diagnostics

Filter dianostics

Suppress diagnostics

Disable checks

Load diagnostics from YAML files

View class hierarchy

{Class View}

Command-line options

Using custom styles

Set up code coverage from Coco

Set Coco installation directory

Create a build configuration for Coco

Set code coverage for a project

qmake projects

CMake projects

Specify code style

Editing code

Writing code

Navigating code

Using tabbed editors

Using minimap

Editor toolbar

Hiding options

Adding space around toolbar items

Resizing views

Copying file information

Editing selected lines

Complete code

Summary of available types

Complete code snippets

Configuring projects locally

Building and running projects

Specifying build settings

Specifying deploy settings

Specifying run settings

Configuring Qt Creator

Checking build and run settings

Adding your own code snippets

Configuring version control systems

Managing plugins and extensions

Accessibility

Changing keyboard shortcuts

Navigating with the keyboard

Setting zoom levels

Changing color schemes

Use GitHub Copilot

Requirements

Set Copilot preferences

Receive suggestions

Turn suggestions on and off

Toggle Copilot suggestions

Turn suggestions on or off for a project

Detect errors in C++ code with Cppcheck

Analyze selected files

Performance Analyzer

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

Chrome Trace Format Visualizer

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

Add custom output parsers

Set custom parser preferences

Debug mode views

Managing Debug views

Customizing Debug views

Supported debuggers

GDB versions

Debugging tools for Windows

Debugging tools for macOS

LLDB versions

PDB versions

Show tooltips for simple values

Debugger Log

Directly interacting with debuggers

General debugger preferences

Breakpoints

Source paths mapping

Add debuggers

Remove debuggers

Tutorial: C++ debugging

{Debugging a C++ Application}

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

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

Setting up the debugger

Showing more debuggers

Launching the debugger

GDB run modes

Stopping applications

Examining data

Remote debugging

Using debugging helpers

QML and Qt Quick

Copy application files to Boot to Qt devices

Launch applications on boot

Deploy applications to remote Linux devices

Add missing files

CMake builds

qmake builds

Deploy steps

Upload files

Create a tarball

Specify QNX Neutrino deploy settings

Find configured devices

Desktop platforms

Linux

macOS

Windows

Compiling from source

Developing for Android

Requirements

Developing for Boot to Qt devices

Protecting device connections

Developing for Bare Metal devices

Debug server providers

Developing for remote Linux devices

Protecting device connections

Developing for iOS

iOS 17 devices

Specifying supported iOS versions

Developing for MCUs

Requirements

Qt for MCUs SDKs

Developing for QNX Neutrino devices

Compare files

View unsaved changes

Compare two files

View changes

Revert and apply changes

Reload files

Paste changes for review

Change colors

Viewing disassembled code

Starting disassembler

Paste and fetch code snippets

Paste snippets

Fetch snippets

Set code pasting preferences

Set a shared network drive for code pasting

Use external tools

Configure external tools

FakeVim modes and commands

Normal and visual modes

Command-line mode

Insert mode

Options

Vimrc example

Search in current file

Set search criteria

Replace text

Preserve case when replacing

Highlight search hits

Search globally

Find symbols

Find references to a symbol

Color-code access type

Find symbols that match search criteria

View found symbols

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

Apply quick fixes

Create functions

Implement member functions

Insert virtual functions

Create getters and setters

Generate constructors

Move classes to separate files

Specify editor settings

Enclose code in brackets or quotes

Evaluating expressions

Adding expression evaluators

JavaScript expressions

C and C++ expressions

Function calls

Ranged syntax

Compound variables

Optimized builds

GCC

Expressions view actions

FAQ

General questions

Qt Widgets Designer Integration Questions

QML and Qt Quick questions

Help questions

Debugger questions

Compiler questions

Qt installation questions

Platform related questions

Questions about new features

Adding files

Select file type

View file system

{File System}

File System context menu

File System view toolbar

Getting started

Glossary

Heob

Recording results

Handling exceptions

Raising exceptions on errors

Protecting pages

Handling leak data

Download highlight definitions

Remember preferred definitions

Download definitions

Ignore file patterns

Add your own definitions

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

Use environment variables from a file

Activate custom output parsers

Activate kits for a project

Change and add kits

Copy custom settings from vanished targets

Add Boot to Qt devices

Reboot devices

Restore default applications

Add Bare Metal devices

Add the device to a kit

Add bookmarks to help pages

Import and export bookmarks

Add breakpoints

Add CMake tools

Add or remove CMake tools

Set the default CMake tool

Add CMake tools to kits

Add code snippets to the auto-complete menu

Add custom compilers

Add designs from Figma to Qt

Integrate Figma to Qt content into Qt Quick applications

Create a Qt Quick Application project for Figma to Qt content

Edit converted files in the Design mode

Add external documentation

Add libraries to CMake projects

Import existing libraries

Use dependencies

Find CMake module files

Add generic language servers

Add a Java language server

Add external libraries to Android packages

Add OpenSSL libraries

Add a license header template for C++ code

Add MCP servers

Connect to MCP servers

Add MCP servers from the registry

Add MCU devices

Add MCU SDKs

Add Nim compilers

Add a QNX Neutrino device

Use a wizard to add a device

Manually add a device

Add remote Linux devices

Use a wizard to add a device

Manually add a device

Add subprojects to projects

Create subprojects

Add existing projects as subprojects

Create SUBDIRS projects for qmake

Specify dependencies

Remove subprojects

Add tests to existing test projects

Add translation files

Add wizards

Search in projects or file systems

Search in a single project

Search in all projects

Search in the file system

Search and replace

Analyze CPU usage

Collect data

Profile memory usage on devices

Generate separate debug info for qmake projects

Edit Android manifest files

Create a manifest file

Set manifest file options

Screen orientation

Icons

Splash screens

Permissions

Assign keyboard shortcuts

Record key sequences

Attach the debugger to running applications

Attach the debugger to starting processes

Automatically format QML/JS files

Build and run tests

Select tests to run

Run and debug tests from code editor

Run CTest tests from the locator

Turn on build system based tests

Locate Qt Test data tags

Build on Docker devices

Build applications on remote Linux devices

Build for and run on Docker devices

Build with GN

Open GN projects

Add GN tools

Add GN tools to kits

Change editor colors

Export and import color schemes

Import and export keyboard shortcuts

Change text encoding

Set default encoding

Change the UI language

Set the language from the command line

Collect usage statistics

Principles of data collection

Turn on data collection

Collected data

Complete CMake code

Configure Clang diagnostics

Select Clazy check levels

Create Clang-Tidy configuration files

Override CMake settings for a project

Configure language servers for projects

Turn on and off language servers

Configure language server workspace

Configure Python language servers

Configure SSH connections

Configure development tools

Connect Boot to Qt devices

Connect iOS devices

Create a connection to an iOS device

View device connection status

Access files on iOS devices

Connect remote Linux devices

Connect to Squish Server

Create SSH connections to VxWorks devices

Configure the VxWorks source build

Configure the VxWorks kernel

Create a startup script

Test the connection

Contact Qt

Report bugs and suggest improvements

Join discussions

Configure C++ code model

Create an Android Virtual Device (AVD)

Create Boost tests

Create Catch2 tests

Create class diagrams

Add relations

Create self-relations

Add and delete points

Specify members

Create compiler explorer sessions

Create component diagrams

Create C++ classes

Create CTest Based Tests

Create Google tests

Create Lua scripts

Run Lua scripts

Edit Lua scripts

Create UML-style models

Create scratch models

Create Nimble projects

Create OpenGL and Vulkan shaders

Create package diagrams

Create kits for QNX Neutrino devices

Create Qt tests

Create Qt Interface Framework projects

Create Qt Quick tests

Create Qt Quick UI Prototypes

Create resource files

Sort resource files

Set a path prefix

Set a locale

Remove resource files

Create Squish test suites

Create state charts

Create vcpkg manifest files

Create VCS repositories for new projects

Create kits for VxWorks devices

Debug on Android devices

Enable debugging on devices

Select a debug build configuration

Resolve conflicts with a second debugger

Use Android Emulator

Debug CMake project files

Start and debug an external application

Debug crashed processes on Windows

Debug remotely with CDB

Debug remotely with GDB

Application running, SSH access to remote machine available

Application not running, terminal access to remote machine available

Application running, terminal access to remote machine and gdbserver available

Use SSH port forwarding

GDB server started by a command

Debug C++ applications on VxWorks devices

Deploy applications to Android

Specify deployment settings

Select a device for deployment

Remove previous installations

Install pre-built APKs

Detach the help window

Detach views

Attach views

Revert changes

Document code

Set up EBlink

Edit CMake configuration files

Install missing Qt packages

Edit environment settings

Set variable separators

Edit Qbs profiles

Edit vcpkg manifest files

Add packages to manage

Generate code for CMake configuration files

Set the path to vcpkg

Edit like in Vim

Escape FakeVim mode

Quit FakeVim mode

Enable and disable plugins

Enable debugging

Debug C++

Debug Qt Quick

Examine complex values in Debug views

Exclude files from to-do lists

Explore compiler code

Set compiler options

Change the server URL

Create pixmaps from SVG images

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

Reset Qt Creator settings

Override the default settings path

Start Qt Creator with temporary clean settings

Format CMake files

Generate SSH keys

Review code with Gerrit

Push drafts to Gerrit

View changes as in Gerrit

View details of changes

Cherry-pick changes

Checkout changes

Refresh changes

Getting help

Change the font

Return to the editor

Select help viewer backend

View function tooltips

git amend

Amend related commits

Create and apply patches

git blame

Hide blame in the editor

View blame for the whole file

View blame in previous versions

git branch

Filter entries and tags

Add branches

Manage branches

git clean

git commit

Apply actions to files

Resolve conflicts

Apply actions to commits

git diff

Fold diff chunks

Toggle unified and side-by-side views

Stage and unstage changes

git fetch

Commit your first change

Configure your user credentials

Commit to a new repository

Commit to an existing repository

Show instant blame

Instant blame tooltip

Instant blame settings

Interactive rebase

Rebase from the change log

git log

View log entry details

Toggle the diff view

Use the patience diff algorithm

Ignore whitespace changes

Filter log entries

Show log for all local branches

Follow only the first parent

Toggle text and graph

Toggle colors

Show log for previous names of the file

Show details

git merge

Configure merge tools

git pull

Manage uncommitted changes

Pull with rebase

git push

git reflog

git reset

Reset all uncommitted changes in the current file

Reset changes in the local repository

Revert commits in the editor

Stage changes

Stage the current file

Unstage the current file

Stage chunks or lines

git stash

Stash local changes

Manage stashed changes

Take a snapshot

Pop stashes

git status

Show file status

Show git status

Git Tools

Git Gui

Gitk

Other repository browsers

Git Bash

Merge tools

Use Git with Subversion

View Git Subversion log

Publish commits to Subversion

Initialize Git repositories

Insert multiple cursors

Inspect basic Qt objects

Change value display format

Change variable values

Signal-slot connections

Low-level data

Inspect the code model

Inspect language clients

Check language server capabilities

Inspect memory usage

Install extensions

Install extensions from external repositories

Update extensions

Remove extensions

Security considerations

Install plugins

Installation

Qt Online Installer

Standalone Qt Creator

Using package managers

Downloading installation packages

Building from sources

Set up J-Link

Apply filters before scanning for tests

Link projects with GitLab

Load core files to the debugger

Get core files

Attach to a core file

Attach to the latest core file

Activate extensions

Locate files using the keyboard

Manage Android NDK packages

Download Android NDKs

Set default NDK

Add NDK paths

Manage Android SDK packages

Show SDK packages

Update SDK packages

Set sdkmanager options

Manage AVDs

Start AVDs

Set preferences for starting AVDs

Remove AVDs

Manage breakpoints

Move breakpoints

Delete breakpoints

Turn breakpoints on and off

Manage device processes

Manage extensions

Manage files in CMake projects

Manage remote repositories

Manage MCU kits

Change or remove MCU kits

Manage Squish test suites and cases

Record test cases

Run test suites

Map symbolic names

Inspect local variables

Manage Windows App SDK packages

Set up Qt Creator MCP server

View MCP server status

Use MCP clients

Inspect client communication

Detect memory leaks with Memcheck

View memory issues

Filter memory issues

Move between files

Locate files

Locate files from global file system index

Browse location history

Navigate with the keyboard

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

Move in QML code

Locate QML methods

Find QML types

Inspect QML and JavaScript

Move between QML and C++

Open UI files in Qt Design Studio

Set up OpenOCD

Specify Clang tools settings

Specify clangd settings

Create Android packages

Select API Level

Build AABs

Build AARs

Parse build output

Paste text from clipboard history

Perform calculations

Built-in functions

Preview images

Profile CMake code

Profile QML applications

Save and load data

Flush data while profiling

Attach to a running Qt Quick application

Read CMake documentation

Record screens

Set the screen and area to record

Edit recordings

Rename symbols

Rename C++ symbols

Rename QML types

Replace found symbol instances

Parse files

Select parse context

Reparse externally changed files

Specify a custom executable to run

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

Analyze the applications

Create MCU projects

Run on QNX devices

Troubleshoot errors

Debug output cannot be shown

Cannot run, debug, or stop applications

Run on remote Linux devices

Run Python applications

Specify Python run settings

Specify custom executable run configuration

Run qmake before building

Run QML files

Run applications in a web browser

Search and replace using a regular expression

Search from documentation

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 line ending style

Set default style

Select Squish AUTs

Map AUTs

Specify AUT paths

Add attachable AUTs

Specify settings for running tests

Set up Android development environment

Manual setup

View Android toolchain settings

Set the default build and run directories

Set the default build directory

Set the default working directory

Set C++ file naming preferences

Set data breakpoints

Select the help start page

Set high DPI scaling

Set the number of recent files shown

Use Vale

Set a Vale configuration file

Run Vale

Set Vale preferences

Set up version control systems

General VCS preferences

Set up Git

Show and hide the main menu

Show and hide sidebars

Sign Android packages

Create a keystore and certificate

Sign a package

Turn on Silver Searcher

Set location of Silver Searcher

Specify project contents

CMake projects

qmake projects

Specify settings for quick fixes

Split the editor view

Move between views and windows

Remove splits

Start debugging from the command line

Start debugging

Execute GDB or CDB commands

Debug Python projects

Debug console applications

Step through code

Compress steps in GDB

Step into Frameworks in macOS

Set up St-Link

Switch between modes

Hide and show modes

Switch to Edit mode

Switch UI themes

Test on iOS Simulator

Turn on crash reports

Location of crash reports

Use the ACP Client

Prerequisites

Configure an agent

Preconfigured agents

Custom agents

Connect to agents

npx

Claude CLI

Open the ACP chat window

Connect to an ACP server

Inspect ACP communication

Chat window toolbar

Chat with the agent

Context in messages

Agent's responses

Typical workflows

Explain and explore

Refactor with review

Build and fix

Bookmark code

Add notes to bookmarks

Navigate bookmarks

Locate bookmarks

View bookmarks

Highlight code blocks

Fold code blocks

Fold all comment blocks

Animate matching braces

Move between code blocks

Use common VCS functions

Track 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

Switch between editor types

Add editors to Tools menu

Use Git for Windows

Detect memory leaks with Heob

Use info bars instead of pop-ups

Use junction points on Windows

Junction points

Use project wizards

Select project type

Bind keyboard shortcuts to wizards

Configure QML Language Server

Turn off QML Language Server for all projects

Use advanced features

Select QML Language Server version

Automatically configure new CMake projects

Use Qt Creator variables

Pattern substitution

Use default values

Examples

Current document variables

Kit and build configuration variables

Qt variables

Device variables

Git variable

Use Qt Linguist

Use Zen Mode

Toggle distraction free mode

Toggle zen mode

Set Zen Mode preferences

Set up the uVision IDE

uVision Simulator

uVision St-Link or JLink Debugger

View CMake project contents

Re-configure CMake projects

Hide subfolder names in Projects view

View code coverage reports from Coco

Disable viewing of code coverage from Qt Creator

Change fonts and colors

View images

View output

Change text encoding

Find and filter output

Save output as a file

Write down notes

How to

Adapt the UI

Analyze

Build and run

Build with CMake

Build with qmake

Manage kits

Run projects

Configure Qt Creator

Create projects

Add files

Configure projects

Debug

Design UIs

Design Qt Quick UIs

Use UI components

Add animation

Work with states

Design widget-based UIs

Develop for devices

Android

Bare Metal

Boot to Qt

Docker

iOS

MCUs

QNX Neutrino

Remote Linux

VxWorks

WebAssembly

Windows desktop

Edit code

Configure editors

Manage language servers

Search

Edit state charts

Edit UML-style models

Read documentation

Test

Use AI

Use Git

Current file

Current project

Local repositories

Commits

Remote repositories

View include hierarchy

{Include Hierarchy}

Indent text or code

Don't detect indentation settings

Fix indentation in an open file

Indentation options

Automatically fix indentation upon file save

Show whitespace in editor

Display right margin

Keyboard shortcuts

Conflicting shortcuts

Showing shortcuts in menus

Top 5 general shortcuts

Top 5 locator shortcuts

Top 10 editor shortcuts

Top 5 debugger shortcuts

Top 5 Git shortcuts

General keyboard shortcuts

Document navigation shortcuts

Exit Qt Creator

File management shortcuts

Find-and-replace shortcuts

Text editing shortcuts

UI navigation shortcuts

Mode shortcuts

Output view shortcuts

Sidebar view shortcuts

Editor shortcuts

Bookmark shortcuts

Code block shortcuts

Code line shortcuts

Code navigation shortcuts

C++ editing shortcuts

FakeVim shortcuts

Font size shortcuts

Snippet shortcuts

Split view shortcuts

Text editing macro shortcuts

Build-and-run shortcuts

Debugger shortcuts

Help mode shortcuts

Image viewer shortcuts

Project shortcuts

Qt Quick shortcuts

Qt Quick Designer shortcuts

Timeline shortcuts

Transitions shortcuts

Qt Widgets Designer shortcuts

Version control shortcuts

VCS shortcuts on macOS

Emacs shortcuts

Known issues

General issues

Editing issues

Projects issues

Debugging issues

Managing language servers

Adding MIME types for language servers

Adding language servers

Updating Python language server

Supported locator filters

Reporting issues

Preview a QML file on desktop

Preview Qt Quick UIs on devices

On Android

On Boot to Qt

Local variables and function parameters

Locals view actions

Selecting object type for display

Inspect internal logs

View logs

Record text editing macros

Record macros

Play macros

Save macros

Assign keyboard shortcuts to macros

Edit Markdown files

Format text

Move to a line and column

Follow links to web sites

Edit MIME types

Change predefined MIME types

Change default editor for a file type

Add magic headers

Reset MIME types

Editing UML-style models

Editing models

Grouping elements

Aligning elements

Managing elements

Linking from element names to files

Zooming into diagrams

Printing diagrams

Exporting diagrams as images

Adding custom elements

Using definition files

Viewing modules

Breaking on loading modules in CDB

View open documents

{Open Documents}

Setting preferences for opening files

Supported platforms

View outline

Outline

Overview

Managing projects

Designing user interfaces

Writing code

Semantic highlighting

Finding

Refactoring code

Configuring the text editor

Building, deploying, and running applications

Debugging applications

Finding issues in source code

Running tests

Using Squish

Publishing applications

Qt tools

Peripheral Registers

Set global preferences for Clang tools

Connect to Axivion dashboard servers

Map paths

Local analyses

Beautifier

Specifying Beautifier preferences

Beautifier tool preferences

Using a predefined ClangFormat style

Defining a style

Valgrind Callgrind

Enabling full cache simulation

Enabling branch prediction simulation

Clangd

Clang checks

Code Model

Inspect preprocessed C++ code

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

CDB Paths

CDB

GDB

Executing additional commands

Extended GDB preferences

Set preferences for Docker devices

Modify entry points

Specify paths to mount

Auto-detect kit items

Set compiler preferences

Managing kits

Filtering kit preferences

Kit preferences

Configure the locator

Change locator filters

Add web search engines

Create locator filters

Configure locator cache

Hide long paths

Valgrind Memcheck

Setting stack trace length

Tracking origins of uninitialized memory

Viewing a summary

Showing reachable and indirectly lost blocks

Suppressing errors

Nim

Code Style

Tools

Set Qbs profile directory

Specify Qt Quick code style

Use the built-in formatter

Use qmlformat

Use a custom tool

Set up screen recording

Testing

Qt Tests

Google Tests

Boost Tests

Catch2 Tests

CTest-Based Tests

Behavior

Specifying tab preferences

Specifying tabs and indentation

Setting typing preferences

Completion

Code completion behavior

Automatically inserting matching characters

Configuring editors

Configuring fonts

Snippets

Editing snippets

Removing snippets

Resetting snippets

CMake

Supported CMake versions

Conan package manager

Automatic package manager setup

Creating projects

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

IncrediBuild

Manage sessions

Create new sessions

Open sessions

Open sessions from the locator

Use workspaces

Move views in a workspace

Manage workspaces

Restore a workspace on startup

Create a custom workspace

Meson

Adding Meson tools

Editing Meson build descriptions

Code completion and external libraries

Current Meson support limitations

Nimble

Open projects

Partially supported project types

Open project files

Open directories as projects

Re-configure projects

Import builds

Show progress information

Qbs

Building Qbs

Add libraries to qmake projects

Library location

Target platform

Linking

Development platform

Add Qt versions

Register installed Qt versions

Set up new Qt versions

Register documentation

Troubleshoot Qt installations

Self-built Qt versions

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

Autotools

Working with Autotools projects

View projects

Projects

Projects view context menu

Projects view toolbar

Develop Qt for Python applications

Set up PySide6

Create Qt for Python applications

Select the Python version

Create kits for Python

Manage Python versions

Use virtual environments as kits

Change the debugger for a Python kit

Use Python interactive shell

Tutorial: Qt Quick debugging

{Debugging a Qt Quick Application}

Examine local variables

Remove a breakpoint

Show application on top

Using QML modules with plugins

Developing with Qt 6.1 or earlier

Generating type description files

Dumping plugins automatically

Importing QML modules

Running QML modules in Design mode

Profiling QML 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

Use Qt AI Assistant

Install Qt AI Assistant

Enable code syntax highlighting in the inline chat window

Install and use Ollama

Run models on Ollama

Supported models from Ollama

Custom models

Connect to an LLM

Automatic code-completion

Complete code from the keyboard

Enter prompts and smart commands

Request suggestions using human language

Request code review

Request test cases in Qt Test syntax

Configure the main project CMakeLists<@op>.</@op>txt

Configure the test project CMakeLists<@op>.</@op>txt

Configure the main project main<@op>.</@op>cpp

Configure external test projects

Request code documentation in Markdown format

Request fixing of code

Request explaining of code

Add inline comments

Adapting the UI

Take courses at Qt Academy

What's new?

UI files

Supported methods

JavaScript functions

Qt QML methods

Using UI files

Analyzers

View application output

{Application Output}

Application Output Preferences

Build systems

View compile output

{Compile Output}

Compile Output Preferences

C++ quick fixes

Block of code selected

Class

Class member

Control statement

Function declaration or definition

Identifier

Numeric literal

Operator

String literal

<@keyword>using</@keyword> directive

Miscellaneous

Debuggers

Developing for devices

Embedded platforms

Mobile platforms

Other platforms

Developing for Docker

Editors

View issues

Issues

Clear the view

Parse build output

Toggle Clang diagnostics

View the source code

Annotate issues

Copy lines

View more information in other views

Get help on the issue

JavaScript and QML checks

Enabling and disabling messages

JavaScript and QML error codes

Resetting the code model

Platforms

Quick Fixes

Function locations

Function names and attributes

Namespace handling

Custom parameter types

FakeVim

Setting Vim behavior

Emulating plugins

Mapping FakeVim commands

Mapping user commands

Add to-do keywords

QML quick fixes

Qt Quick UI design

View search results

{Search Results view}

Define a search scope

Define search criteria

View the search results

Use the Search Results view toolbar

View Squish output

Squish

View Squish test log

View Squish runner and server logs

Squish view toolbar

Open a terminal

View output in the terminal

Run Qt Creator commands from the terminal

Insert Qt Creator variables

Set keyboard shortcut preferences

Run terminal in a separate window

Use system terminal on Linux and macOS

To-do entries

Designing UIs

Reference

Viewing and editing register state

Examining memory

Specify Android run settings

am start options

Shell commands

Run on Boot to Qt devices

Specify run settings for Boot to Qt devices

Run on the desktop

Working directory

Run in terminal

Linker libraries

Debug linked frameworks

Filter logging categories

Run as a different user

Specify QNX run settings

Specify Qt Quick UI Prototype run settings

Specify remote Linux run settings

View the application UI

Run as a different user

Specify Valgrind settings for a project

Configure projects for running

Manage run configurations

Remove run configurations

qmake run configurations

Select the default run target

CMake run targets

qmake run targets

Meson run targets

Running applications

Running on mobile and embedded devices

Selecting run targets

Running without deploying

Running without building

Run Valgrind tools on external applications

Editing SCXML state charts

Navigating state charts

States

Adding states

Aligning and editing states

Viewing state tree structure

Managing transitions

Adding executable content

SDK Tool

Value types

SDK path

Options

Operations

Adding a system architecture (ABI)

addAbiFlavor

addAbiFlavor options

ABI flavor example

Adding CMake tools

addCMake

addCMake options

CMake configuration example

Adding compilers

addTC

addTC options

Compiler example

Adding debuggers

addDebugger

addDebugger options

Debugger example

Adding devices

addDev

addDev options

Linux device example

Adding Qt versions

addQt

addQt options

Qt version example

Adding kits

addKit

addKit options

Kit example

Adding, getting, and finding keys

Removing configured items

Searching

Set up WebAssembly development environment

Share project settings

Create a shared settings file

Update shared settings

Share CMake project settings

Viewing source files

External sources

Viewing call stack trace

Loading QML stack

Add kits

Set the default kit

Show task list files in issues

Manage task list entries

Task list file format

View test results

View Qt test output

Summary of messages

Filter test results

Blacklist tests

Viewing threads

Add compilers

Re-detect compilers

Add C or C++ compilers

Supported compilers

Bare-metal compilers

Troubleshoot MinGW compilation errors

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

Tutorial: Use internal libraries with qmake

Create a shared library

Link an application to the library

Tutorial: Qt Quick and Python

{Creating a Qt for Python Application with Qt Quick}

Create an empty project

Install PySide6 for the project

Add Qt Quick imports

Add a main function

Load the QML file

Design the UI

Add imports

Add properties and functions

Add Qt Quick Controls

Run the application

Tutorial: Qt Widgets UI and Python

Create a window UI project

Install PySide6 for the project

Design a widgets-based UI

Run the application

Tutorial: Qt Widgets and Python

{Creating a Qt for Python Application with Qt Widgets}

Create an empty window project

Install PySide6 for the project

Add Qt Widgets imports

Add a widgets-based UI

Add signals and slots

Add a main function

Instantiate the MainWindow class

Execute the Qt code

Run the application

Tutorials

View type hierarchy

{Type Hierarchy}

Optimizing applications for mobile devices

Using AI

Designing widget-based UIs

Code editor integration

Manage image resources

Set preferences for Qt Widgets Designer

Preview forms using device profiles

Add device profiles

Designing Qt Quick UIs

Open design views

Set up vcpkg package manager

Set up vcpkg

Set the path to vcpkg

Turn off automatic setup

Bazaar and Breezy

Additional Bazaar and Breezy functions

Uncommitting revisions

Bazaar and Breezy preferences

ClearCase

Using GNU Diffutils with ClearCase

Checking out and checking in

ClearCase preferences

CVS

CVS preferences

Fossil

Configuring Fossil

Additional Fossil functions

Fossil preferences

Using Git

Getting started with Git

Working with the current file

Working with the current project

Working with local repositories

Working with remote repositories

GitLab

Connecting to GitLab servers

Cloning projects

Mercurial

Mercurial preferences

Perforce

Configuring Perforce

Using configuration files

Additional Perforce functions

Subversion

Subversion preferences

Version control systems

Developing for VxWorks

Building applications for the web

Developing for the Windows desktop

Tutorial: Qt Widgets application

{Creating a Qt Widget Based Application}

Create the Text Finder project

Fill in the missing pieces

Design the user interface

Complete the header file

Complete the source file

Create a resource file

Add resources to the project file

Build and run your application

Use Development Containers

Configure dev containers

Customization options for dev containers

Configuration for typical local development

Configuration for custom kits and toolchains

Qt Creator Documentation

{Qt Creator Manual}

About

Edit properties of QML types

Preview images

Format text

Preview animations

Edit rectangles

Show toolbars immediately

Pin toolbars

Gumbo, version 0.10.1

litehtml, version 0.9

CMake Lexer

conan.cmake

conan.cmake

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

MCP Server

Open Source Front-End for C++

JSON for Modern C++, version 3.11.2

kikito/inspect.lua

kikito/inspect.lua

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: jinja.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

KSyntaxHighlighting, version v5.103.0

libvterm, version 0.3.3

Lua, version 5.4.6

ms-jpq/lua-async-await

Pty-Qt/ConPty, version a38388615e

Pty-Qt, version 045ca5f09f

pyprof2calltree

QtKeychain, version 0.15.0

sol2, version 3.3.1 (revision 9c882a28)

Source Code Pro Font

SQLite, version 3.49.1

std::span Implementation for C++11 and Later, version 00afc28

TartanLlama/expected

Shellintegrations/Clink, version 680716f3d9

Shellintegrations, version 463d9933a4

Apache Tika MimeType Definitions, version 019041117149667bc4d18fabf222a0670d407959

TOML C++ Parser, version 4.3.0

UI Watchdog, version master

ui_watchdog

RSTParser

WinPty, version 7e59fe2d09

Clazy

LLVM / Clang

LLVMPipe

Qbs

All topics

Annotate designs

Annotate components

Add global annotations

Tutorial: Qt Quick application

{Creating a Qt Quick Application}

Set up the development environment

Create the project

Preview the application

Inspect the QML code

QML imports

Main window

Layout

Basic QML types

Change the properties

Qt Quick Controls

Label

Button

Change the styling

Signals and signal handlers

Inspect the C++ source code

Inspect the CMake configuration file

Run the application on a device

Creating UI logic

Connecting components

Using property aliases and states

Customizing UI controls

Writing expressions

Typical use cases

Edit animation curves

Apply interpolation between keyframes

Unlock properties and easing curves

Lock animation curves

Pin animation curves

Add keyframes to animation curves

Delete keyframes in curves

Edit easing curves

Select easing curves

Easing curves in timeline animations

Attach easing curves to keyframes

Attach easing curves to transitions

Attach easing curves to property animations

Customize easing curves

Use custom fonts

Design 2D UIs

Move components

Resize components

Rotate components

Zoom in and out

Snap to parent and sibling components

Hide component boundaries

Preview component size

Specify canvas size

Set canvas color

Refresh the 2D view contents

Set advanced component properties

Manage mouse and keyboard events

Use layers

Pick colors

Color details

Palette

Pick gradients

Set gradient properties

Linear gradients

Radial gradients

Conical gradients

Select web gradients

Navigate component files

Colorize component icons

Show and hide components in Navigator

Show and hide reference nodes

Show and hide other components

Isolate nodes

Lock components

Arrange components

Add property aliases

Move within components

Optimizing designs

Minimizing image size

Avoiding transparency

Load placeholder data

Use dummy models

Create dummy context

Make layouts scalable

Set bindings

Set anchors and margins

Align and distribute components

Use positioners

Column positioner

Row and the Flow positioners

Grid positioner

Use layouts

Stack Layout

Organize components

Production quality

FPS refresh rate

Profiling UI code

Change properties

View changes in properties

Multiselection

Copy and paste formatting

Edit properties inline

Edit properties in multiple views

Get help for properties

Set basic component properties

Set basic properties

Change component type

Set component ID

Set component name for annotations

Set 2D geometry

Reset component position and size

Manage 2D transformations

Set component visibility

Create a base state

Use states to create application views

Group states

Extend states

Set the default state

Set when conditions

Create conditional bindings

Summary of logical operators

Examples of when conditions

Add transitions between states

Zoom in Transitions

Animate transitions between states

Specify transition settings

Adding animation

Common motion design techniques

Timeline and keyframe based animation

Easing curves

Animation curves

State-to-state animations

Transitions between states

Data-driven UI logic animations

Data-driven timeline animation

Programmatic animation

Animate property changes

Apply animations

Animate color changes

Animate changes in numerical values

Set non-animated properties

Play animations

Play groups of animations

Add pauses between grouped animations

Performance considerations

Summary of the animation components

Add assets

Create buttons

Create component instances

Create custom components

Create components from scratch

Naming conventions

Turn component instances into custom components

Merge files with templates

Using UI components

Component IDs

Using components economically

Insert UI controls

General control properties

Button controls

Button

Highlighted buttons

Flat buttons

Delay button

Check Box

Radio Button

Switch

Round Button

Display text and icons

Checkable buttons

Button signals

Indicators

Busy Indicator

Page Indicator

Progress Bar

Selectors

Slider and Dial

Spin Box

Combo Box

Tumbler

Tab Bar

Tool Bar

Styling controls

Summary of the UI controls

Convert UI projects to applications

Build Qt Quick applications with CMake

Add Studio Components to Qt installations

Handle large data files

Use lists and other data models

List Views and Grid Views

Delegate cache

View highlight

Editing list models

Path View

Summary of the model components

Add custom properties

Add properties for a component

Bind a property value

Add custom properties in the Connections view

Remove custom properties

Supported property types

Import modules

Use images in UIs

Image size

Source size

Image alignment

Performance

Border Image

Animated Image

Summary of the image components

Use preset components

Component types

Create Qt Quick Applications

Add bindings between properties

Create bindings between component properties

Summary of logical operators

Create scalable buttons and borders

Create the button component

Construct the button component

Use states to change component property values

Create shapes

Rectangle

RectangleShape

EllipseShape

RegularPolygonShape

StarShape

Summary of the shape components

Connect components to signals

Create a connection

Add connections

Connect signals to actions

Add conditions

Create JavaScript expressions

Jump to the code

Remove connections

See connections in action

Working with states

Add text to UIs

Use rich text

Mark strings for translation

Character properties

Text alignment

Text and style colors

Advanced text properties

Wrap and elide text

Format text

Render text

Advanced font properties

Text Input

Enter passwords

Enter text

Select text

Focus

Tabs and margins

Padding

Placeholder text

Summary of the text components

Add interaction to UIs

Create mouse areas

Predefined signals

Enable a mouse area

Set hovering

Make mouse areas transparent to mouse events

Respond to mouse buttons

Set cursor shape

Set signal hold interval

Respond to scroll gestures

Propagate events

Prevent stealing

Set drag properties

Set focus scope

Create flickable components

Clipping flickable components

Enable flicking

Set flick direction

Set flick velocity

Set movement

Set Flickable geometry

Summary of the basic interaction methods

Create timeline animations

Add a timeline

Create a timeline

Set keyframe values

Create timelines for use in states

Bind a timeline to a property

Bind animations to states

Manage keyframes

Edit keyframes

Edit keyframe values

Copy keyframes

Delete keyframes

Navigate the timeline

Zoom the timeline

Set keyframe track color

View the animation

Animate rotation

Animate shapes

Technical support

Qt Account

Adoptium OpenJDK

Ant

KSyntaxHighlighting

Artistic Style

Ubuntu bug 662005

Google Breakpad

Expressive Diagnostics

ClangFormat: Documentation

ClangFormat Style Options

Clang Static Analyzer documentation

JSON compilation database format

LibFormat: Documentation

clang-cl

Clang-Tidy

What is clangd

cmake-format

CMake homepage

CMake: add_executable command

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

CMake: Importing and Exporting Guide

CMake: Using Dependencies Guide

CMake: Find Modules

CMake's file-based API

CMake: cmake-packages(7)

CMake: cmake-variables(7)

CMake: cmake(1)

CMake: Install a Project

CTest Manual

CMake: Multi-config generators

CMake: HEADER_FILE_ONLY

CMake: CMAKE_EXPORT_COMPILE_COMMANDS

CMake: CMAKE_OSX_DEPLOYMENT_TARGET

CMake: cmake-presets(7)

Claude: Quick Start

Clazy sources

llvm-project sources

Qbs sources

qt-creator/plugin-telemetry.git

sdk_definitions.json

Qt Creator changelog

project.json

Conan

Development Containers

Cppcheck

curl

What is API Level?

Android NDK

avdmanager

sdkmanager

Configure on-device developer options

Start the emulator from the command line

Android SDK Command-line Tools

Xcode documentation: Configure the list of simulated devices

Apple documentation: Create a development provisioning profile

Enroll in the Apple Developer Program

uVision

JavaScript Expressions and Operators

qt6_am_create_builtin_package

qt6_am_create_installable_package

Boot to Qt: Setting Up USB Access to Embedded Devices

Boot to Qt: Documentation

Qt Application Manager

Qt for MCUs

Getting started on Espressif

Getting started on Infineon PSOC Edge platforms

Getting started on Infineon Traveo T2G

Getting started on NXP (Linux)

Getting started on NXP (Zephyr)

Getting started on NXP (BareMetal and FreeRTOS)

Getting started on STM

Getting started on Renesas

Qt for MCUs - Prerequisites

Qt for MCUs - Supported target platforms

Qt Interface Framework

Coco Manual

Figma to Qt

Qt Documentation

Qbs Manual

Qbs: Modules

Qbs Overview

List of Modules

Qbs Probes

cpp.minimumIosVersion

Creating Plugins

Extending Qt Creator with Lua

Qt Design Studio documentation

Qt for Python

Debugging PySide with Qt Creator (Linux)

Qt for Python Examples and Tutorials

Rust: cargo-build

Conan integration with Autotools

Conan integration with CMake

Conan integration with Meson

conanfile.py

conanfile.txt

Conan integration with Qbs

Docker overview

docker image pull

GitHub Copilot licenses

Gradle

IncrediBuild for Qt Creator

Working with Syntax Highlighting

LLVMpipe introduction

PDB

Eclipse Downloads

Qt Downloads: jom

Official releases

Snapshots of the current and upcoming release

FFmpeg

Fossil SCM client

Options to Request or Suppress Warnings

The Silver Searcher

Git Downloads

GitHub

EBlink

ctf2ctf

Clazy project homepage

Catch2

GitHub Copilot

GitHub: The Silver Searcher

GitHub Copilot for Vim and Neovim

Google C++ Testing Framework

Running a Subset of the Tests

Google Test Primer

JSLint Error Explanations

llvm-project on GitHub

Apache 2.0 License with LLVM exceptions

Proposal of the semantic highlighting protocol extension

Nimble

Python Language Server Configuration

Qt Creator extension registry

Compiling Qt Creator

GitHub: Qt Creator releases

Heob sources

vim-exchange

QML Apps on GitHub

Qt Apps on GitHub

vim-commentary

vim-surround

ReplaceWithRegister

argtextobj.vim

Testing with CTest

GN

Diffutils for Windows

Compiler Explorer

Simulator Help

codellama:13b-code-qml

codellama:7b-code-qml

KCachegrind

KDiff3

dotnet build

DebugView for Windows

Junction points

Latest Windows App SDK downloads

Qt Creator mailing list

LLDB: SBValue Class Reference

Variable Formatting

ClangFormat: Download

LTTng

Qt Marketplace

Android OpenSSL support

The Meson Build system

Debug Adapter Protocol (DAP)

Language Server Protocol

MCP: Tasks

Nim language

Nim IDE Integration Guide

Ninja

Node.js

An introduction to the npm package manager

OpenJDK

OpenOCD

Anthropic account

OpenAI account

uv

Python interactive shell

Qt Project Bug Tracker

QTBUG-12025

SDCC

Sentry: Security & Compliance

Cppcheck: List of checks

Artistic Style Files

Uncrustify Files

Breakpoints, Watchpoints, and Catchpoints

Debugging with GDB: Connecting to a Remote Target

Debugging with GDB: How to Produce a Core File from Your Program

Debugging with GDB: Pretty Printing

Debugging with GDB: Signals

Debugging with GDB: Values From Inferior

Shared MIME-info Database

Prepare the Host System to Use DirectX 9 Accelerated Graphics

How to enable ccache

Uncrustify

Vale: .vale.ini

Suppressing Errors

Interpreting Memcheck's Output

Valgrind's Tool Suite

vcpkg

Libera.Chat: the qt-creator channel

WebGradients

Building Qt Creator from Git

QtCreator Build Gdb

Qt Contribution Guidelines

KernelHardening

Boost.org

Boost.Test

systemd-coredump

Gerrit Code Review

GNU Library General Public License, Version 2

The Emacs Editor

IANA: Media Types

IAR EW

IncrediBuild homepage

ISO 639 language code

JSLint

KDAB: Full Stack Tracing Part 1

Keil

Lua

Markdown

Available NuGet Distribution Versions

OpenSSH

Perforce: P4CONFIG

Qt Academy: Getting Started With Qt AI Assistant

Qt Academy: Getting Started with Qt Creator

Qt Developers

Qt Licensing Overview

Qt Online Installer

Axivion Suite

Squish product page

Qt Appendix for Privacy and Security

Terms & Conditions - Qt Development Framework

Qt Centre: QSsl

J-Link

ST-LINK Utility

Swift

Vim documentation

Hardware 3D acceleration (OpenGL and Direct3D 8/9)

State Chart XML (SCXML)

VxWorks

YAML