Better_Software_Header_Mobile Better_Software_Header_Web

Find what you need - explore our website and developer resources

Working on Multiple Git Branches without Switching

A Git workflow with --rebase-merges and --update-refs

Nicolas Guichard

2 October 2025

Advanced Search

Tags

open sourceperformancetools

Git is today's most popular distributed version control system (DVCS). Initially built for the Linux kernel's needs and a mailing-list-based review flow, it has proven flexible enough to spread to many other software projects and review flows. In fact, Git's flexibility also means your local workflow doesn't have to match your teams' review flow!

In this blog post, I'm going to present my local workflow when working on multiple changes. It mainly revolves around two relatively new Git features:

  • the ability to rebase merges with the --rebase-merges flag introduced in 2018,
  • and rebasing multiple branches at once with the --update-refs flag from 2022.

Using them together, I built a workflow where my changes are cleanly split between multiple branches, yet:

  • I never really switch branch
  • I can see all my changes applied together locally
  • none of my branches are ever left lagging behind
  • adapts to any kind of review workflow

…using only Git's built-in features.

This blog post is going to be heavily command-line based and you can follow along by copy-pasting. If you prefer a lighter video format, switch to my video on the same subject or watch it at the bottom of this blog.

An initial repository

Let's set up an initial repository in git-remote with 2 commits and clone it twice into git-local and git-coworker.

# To make hashes reproducible, set the same author and date to all commits.
export GIT_AUTHOR_NAME="KDAB's Git rebase-merges demo"
export GIT_AUTHOR_EMAIL="info@kdab.com"
export GIT_AUTHOR_DATE="2025-01-22T15:00+0100"
export GIT_COMMITTER_NAME="$GIT_AUTHOR_NAME"
export GIT_COMMITTER_EMAIL="$GIT_AUTHOR_EMAIL"
export GIT_COMMITTER_DATE="$GIT_AUTHOR_DATE"

# Create a bare repository to be our `origin`
mkdir git-remote
pushd git-remote
git init --bare --initial-branch=main
popd

# Clone and simulate some pre-existing work
git clone git-remote git-local && cd git-local
git commit --allow-empty -m "Root commit"
# [main (root commit) 3657733] Root commit
echo "Feature 0" > feature0
git add feature0
git commit -m "Let's pretend some work happened upstream already"
# [main 4010570] Let's pretend some work happened upstream already
git push

# Also create a second clone so we can simulate coworkers
pushd ..
git clone git-remote git-coworker
popd

# Now your repository should look like this:
git log --all --graph --oneline
# * 4010570 (HEAD -> main, origin/main) Let's pretend some work happened upstream already
# * 3657733 Root commit

Create our local-only integration branch

git switch -c integration --track origin/main
# branch 'integration' set up to track 'origin/main'.
# Switched to a new branch 'integration'

That's all, we're set up!

Code, commit, code, commit

Let's not worry about branches for now, and just commit everything linearly to our local integration branch:

echo 'feat 1' > feature1
git add feature1
git commit -m "Feature 1"
# [integration 4f73e16] Feature 1

echo 'bugfix1' >> feature0
git add feature0
git commit -m "Bugfix 1"
# [integration 26aafff] Bugfix 1

echo 'feat 2' > feature2
git add feature2
git commit -m "Feature 2"
# [integration 9fb582c] Feature 2

echo 'feature 1' > feature1
git add feature1
git commit --fixup=4f73e16
# [integration 3ae7dd2] fixup! Feature 1

echo 'feature 2' > feature2
git add feature2
git commit --fixup=9fb582c
# [integration 1b6577f] fixup! Feature 2

echo 'feature 3' > feature3
git add feature3
git commit -m "Feature 3 depends on Feature 2"
# [integration edc0fae] Feature 3 depends on Feature 2

echo 'feature 2 for real' > feature2
git add feature2
git commit --fixup=9fb582c
# [integration 77c318b] fixup! Feature 2

echo 'feature 3 for real' > feature3
git add feature3
git commit --fixup=edc0fae
# [integration 46acd6d] fixup! Feature 3 depends on Feature 2

echo 'feature 1 improved' > feature1
git add feature1
git commit -m "Feature 1 improvement"
# [integration cee864f] Feature 1 improvement

Now we are ready to push our changes for review. But our commits are all mixed up:

git log --graph --oneline
# * cee864f (HEAD -> integration) Feature 1 improvement
# * 46acd6d fixup! Feature 3 depends on Feature 2
# * 77c318b fixup! Feature 2
# * edc0fae Feature 3 depends on Feature 2
# * 1b6577f fixup! Feature 2
# * 3ae7dd2 fixup! Feature 1
# * 9fb582c Feature 2
# * 26aafff Bugfix 1
# * 4f73e16 Feature 1
# * 4010570 (origin/main, main) Let's pretend some work happened upstream already
# * 3657733 Root commit

Let's dispatch them to branches so we can push them for review separately. We will do that with an interactive rebase:

git rebase -i --autosquash --rebase-merges --update-refs

Which initially gives us:

label onto

reset onto
pick 4f73e16 Feature 1
fixup 3ae7dd2 fixup! Feature 1
pick 26aafff Bugfix 1
pick 9fb582c Feature 2
fixup 1b6577f fixup! Feature 2
fixup 77c318b fixup! Feature 2
pick edc0fae Feature 3 depends on Feature 2
fixup 46acd6d fixup! Feature 3 depends on Feature 2
pick cee864f Feature 1 improvement

For each branch we will introduce a block that looks like this:

reset fork-point # where fork-point is a previously-defined label

# picks, rewords, fixups and squashes
# pick    just puts the commit in that branch
# reword  picks the commit and opens the editor to edit the message
# fixup   amends the last commit
# squash  amends the last commit, concatenates both messages and opens the editor

update-ref refs/heads/<branch-name> # update (or create!) a branch <branch-name>
label <label-name>                  # name for use in a later reset or merge in the same rebase

So, here, for instance, to create 3 branches feat/feature1, feat/feature2 and fix/bugfix1 forking from origin/main and a branch feat/feature3 forking from feat/feature2, we would edit that to:

label onto

# Block for the feat/feature1 branch forking from origin/main
reset onto
pick 4f73e16 Feature 1
fixup 3ae7dd2 fixup! Feature 1
pick cee864f Feature 1 improvement
update-ref refs/heads/feat/feature1
label feat1

# Block for the feat/feature2 branch forking from origin/main
reset onto
pick 9fb582c Feature 2
fixup 1b6577f fixup! Feature 2
fixup 77c318b fixup! Feature 2
update-ref refs/heads/feat/feature2
label feat2

# Block for the feat/feature3 branch forking from feat/feature2
reset feat2
pick edc0fae WIP Feature 3 depends on Feature 2
fixup 46acd6d fixup! Feature 3 depends on Feature 2
update-ref refs/heads/feat/feature3
label feat3

# Block for the fix/bugfix1 branch forking from origin/main
reset onto
pick 26aafff WIP Bugfix 1
update-ref refs/heads/fix/bugfix1
label fix1

# Block for the integration branch, merging everything back together
reset onto
merge feat1 feat2 feat3 fix1 # Integration merge commit
# update-ref refs/heads/integration is implicit because it's the current branch

Now our changes are properly dispatched in branches:

git log --graph --oneline
# *---.   acd3986 (HEAD -> integration) Integration merge commit
# |\ \ \
# | | | * 0a7b18e (fix/bugfix1) Bugfix 1
# | |_|/
# |/| |
# | | * 4b12f39 (feat/feature3) Feature 3 depends on Feature 2
# | | * fb102ce (feat/feature2) Feature 2
# | |/
# |/|
# | * 901b6a9 (feat/feature1) Feature 1 improvement
# | * efd7697 Feature 1
# |/
# * 4010570 (origin/main, main) Let's pretend some work happened upstream already
# * 3657733 Root commit

Let's just push all those for review:

git push origin feat/feature1 feat/feature2 feat/feature3 fix/bugfix1
# To git-remote
#  * [new branch]      feat/feature1 -> feat/feature1
#  * [new branch]      feat/feature2 -> feat/feature2
#  * [new branch]      feat/feature3 -> feat/feature3
#  * [new branch]      fix/bugfix1 -> fix/bugfix1

That is if you're using a branch-based review system such as GitHub, GitLab, BitBucket etc.

If you are using Gerrit (the best in my opinion), you would instead git push origin feat/feature1:refs/for/main feat/feature2:refs/for/main feat/feature3:refs/for/main fix/bugfix1:refs/for/main

If you're sending patches to a mailing list (I'm so sorry…), you would use the right git format-patch and git send-email calls.

Handling review comments

After a few hours or days your teammates will review your code and ask for changes. Sometimes those changes require new commits, but most of the time you should fix up existing commits instead.

Let's pretend that Bugfix 1 was good to go and got merged, and that your coworkers committed some other changes, too:

# Bugfix 1 was merged upstream, some other work happened
pushd ../git-coworker
git pull
echo 'Feature 4' > feature4
git add feature4
git commit -m "Your teammates write and merge code too"
git cherry-pick origin/fix/bugfix1
git push
popd

However, the reviewer noticed that you mishandled some edge case for Feature 1 and asked for a new button to trigger Feature 2. We want to amend the existing Feature 1 commit and add a new commit to the feat/feature2 branch.

Just implement and commit both changes in the integration branch:

sed 's/improved/enhanced/' -i feature1
git add feature1
git commit --fixup=901b6a9
# [integration 507b321] fixup! Feature 1 improvement

echo 'Extra button!' >> feature2
git add feature2
git commit -m "Add button for Feature 2"
# [integration 7cb7e39] Add button for Feature 2

Then update your view of origin/main by fetching:

git fetch
# From git-remote
#    4010570..0c0b483  main       -> origin/main

Then launch an interactive rebase on origin/main!

git rebase -i --autosquash --rebase-merges --update-refs
# warning: skipped previously applied commit 0a7b18e
label onto

# Branch feat-feature1
reset onto
pick efd7697 Feature 1
pick 901b6a9 Feature 1 improvement
fixup 507b321 fixup! Feature 1 improvement
update-ref refs/heads/feat/feature1

label feat-feature1

# Branch feat-feature3
reset onto
pick fb102ce Feature 2
update-ref refs/heads/feat/feature2

pick 4b12f39 Feature 3 depends on Feature 2
update-ref refs/heads/feat/feature3

label feat-feature3

# Branch Integration-merge-commit
reset onto
label Integration-merge-commit

reset onto
merge -C acd3986 feat-feature1 feat-feature3 Integration-merge-commit # Integration merge commit
pick 7cb7e39 Add button for Feature 2

If your labels are called Integration-merge-commit Integration-merge-commit-2 and Integration-merge-commit-3, make sure to update to Git 2.48 or later. I was unhappy with those label names and ended up scratching that itch.

The fixup commit is already in the right place, let's just move the Feature 2 button commit:

label onto

# Branch feat-feature1
reset onto
pick efd7697 Feature 1
pick 901b6a9 Feature 1 improvement
fixup 507b321 fixup! Feature 1 improvement
update-ref refs/heads/feat/feature1

label feat-feature1

# Branch feat-feature3
reset onto
pick fb102ce Feature 2
pick 7cb7e39 Add button for Feature 2
update-ref refs/heads/feat/feature2

pick 4b12f39 Feature 3 depends on Feature 2
update-ref refs/heads/feat/feature3

label feat-feature3

# Branch Integration-merge-commit
reset onto
label Integration-merge-commit

reset onto
merge -C acd3986 feat-feature1 feat-feature3 Integration-merge-commit # Integration merge commit

The Integration-merge-commit block doesn't hurt. In fact it is completely useless and you can also remove it.

Our Git log now looks like this:

git log --graph --oneline
# *-.   63861c2 (HEAD -> integration) Integration merge commit
# |\ \
# | | * ab3ac3e (feat/feature3) Feature 3 depends on Feature 2
# | | * 3acce21 (feat/feature2) Add button for Feature 2
# | | * 23b7df9 Feature 2
# | |/
# |/|
# | * f3046c5 (feat/feature1) Feature 1 improvement
# | * 7e93e38 Feature 1
# |/
# * 0c0b483 (origin/main) Bugfix 1
# * 57c50bf Your teammates write and merge code too
# * 4010570 (main) Let's pretend some work happened upstream already
# * 3657733 Root commit

We can push feature1, feature2 and feature3 for review again:

git push origin feat/feature1 feat/feature2 feat/feature3 --force-with-lease --force-if-includes

--force-with-lease and --force-if-includes ensure that we're not overwriting anything if someone else pushed to those branches.

Bonus section

Alternatives

The workflow I describe here has the advantage of only requiring base Git. You might also like Jujutsu or GitButler, which enable similar workflows.

Jujutsu

Jujutsu is a recent Version Control System currently using Git as backend. The main difference with the workflow described here is that jj automatically rebases commits. When with Git you git commit --fixup=<some_hash> && git rebase -i, with Jujutsu you only have to jj squash --into <some_hash>.
See this Jujutsu introduction and, especially, the “Pattern: Working on two things at the same time” section for an example.

GitButler

GitButler is “a Git client for simultaneous branches on top of your existing workflow“. It provides a nice GUI for this precise use-case. Like Jujutsu it removes the need for git rebase -i and rebases commits automatically. When with Git you git commit --fixup=<some_hash> && git rebase -i, with GitButler you drag and drop files to the relevant commit.
See the GitButler docs for more information.

Keeping local-only changes

I usually have two kinds of changes I don't want to push upstream: Work-In-Progress commits and local configuration.

I just keep WIP commits at the tip of the integration branch, downstream of the merge commit.

My local configuration lives in a local-do-not-push branch, merged together with the other feature branches. I just never push it.

This typically looks like this:

git log --graph --oneline
# * 9c28203 (HEAD -> integration) WIP Feature6
# *---.   f75840e Integration merge commit
# |\ \ \
# | | | * ab3ac3e (feat/feature3) Feature 3 depends on Feature 2
# | | | * 3acce21 (feat/feature2) Add button for Feature 2
# | | | * 23b7df9 Feature 2
# | |_|/
# |/| |
# | | * f3046c5 (feat/feature1) Feature 1 improvement
# | | * 7e93e38 Feature 1
# | |/
# |/|
# | * 0332875 (local-do-not-push) My local editor config
# |/
# * 0c0b483 (origin/main) Bugfix 1
# * 57c50bf Your teammates write and merge code too
# * 4010570 (main) Let's pretend some work happened upstream already
# * 3657733 Root commit

Making sense of the Git log

git log has a bad default:

By default, the commits are shown in reverse chronological order.

For the example above, I get this nonsense:

git log --oneline
# 9c28203 (HEAD -> integration) WIP Feature6
# f75840e Integration merge commit
# 0c0b483 (origin/main) Bugfix 1
# 0332875 (local-do-not-push) My local editor config
# f3046c5 (feat/feature1) Feature 1 improvement
# ab3ac3e (feat/feature3) Feature 3 depends on Feature 2
# 57c50bf Your teammates write and merge code too
# 7e93e38 Feature 1
# 3acce21 (feat/feature2) Add button for Feature 2
# 4010570 (main) Let's pretend some work happened upstream already
# 23b7df9 Feature 2
# 3657733 Root commit

Therefore, I recommend always using either --graph as above or at least --topo-order:

git log --topo-order --oneline
# 9c28203 (HEAD -> integration) WIP Feature6
# f75840e Integration merge commit
# ab3ac3e (feat/feature3) Feature 3 depends on Feature 2
# 3acce21 (feat/feature2) Add button for Feature 2
# 23b7df9 Feature 2
# f3046c5 (feat/feature1) Feature 1 improvement
# 7e93e38 Feature 1
# 0332875 (local-do-not-push) My local editor config
# 0c0b483 (origin/main) Bugfix 1
# 57c50bf Your teammates write and merge code too
# 4010570 (main) Let's pretend some work happened upstream already
# 3657733 Root commit

Unfortunately, this doesn't have a git config option… yet!

Avoiding the command-line boilerplate

Typing git rebase -i --rebase-merges --update-refs --autosquash every time is quite heavy. Your shell history should make this easier, but still… Luckily, those can be set in the git config:

git config --global rebase.rebasemerges true
git config --global rebase.updaterefs true
git config --global rebase.autoSquash true

Avoiding the git-rebase-todo boilerplate

Editing the rebase todo-list takes some time getting used to. While Git generates all the boilerplate for existing branches, creating a new branch takes at least:

t onto
u refs/heads/<branch_name>
l <label>
m <label>

Fortunately, most editors have support for macros!

For Kate, I have a macro that writes the boilerplate above and sets the cursor at the end of the update-refs, label and merge lines. After writing the branch/label name I just have to move lines around.

My colleague Magnus Groß wrote a Vim plugin to efficiently create new branches, move commits around and even push directly from the git rebase todo-list, you can find it here.

Stay tuned for more tooling improvements around this workflow!

Switch-less Git Branching

To watch this video on our website please or view it directly on YouTube

Tags:

open sourceperformancetools

About KDAB

The KDAB Group is a globally recognized provider for software consulting, development and training, specializing in embedded devices and complex cross-platform desktop applications. In addition to being leading experts in Qt, C++ and 3D technologies for over two decades, KDAB provides deep expertise across the stack, including Linux, Rust and modern UI frameworks. With 100+ employees from 20 countries and offices in Sweden, Germany, USA, France and UK, we serve clients around the world.

I have read and agree to the privacy policy.

KDAB is committed to ensuring that your privacy is protected.

  • Only the above data is collected about you when you fill out this form.
  • The data will be stored securely.
  • If you wish for us to erase it, email us at info@kdab.com.

For more information about our Privacy Policy, please read our privacy policy.
NicolasGuichard

Nicolas Guichard

Software Engineer

Nicolas Guichard is a Software Engineer at KDAB.

Related Content

Can't the Compiler Do That?

Customized C/C++ Tooling with Clang LibTooling

KDE's Akademy 2020 - A Quick Summary

Understanding Type-Based Alias Analysis in C and C++

How type systems shape compiler optimizations

Sign up for the KDAB Newsletter

Stay on top of the latest news, publications, events and more.

Go to Sign-up

Need help with performance issues?

Let the KDAB experts solve concrete performance problems, improve your software architecture or teach your team how to apply debugging and profiling tools to your developement process in the best way.

Get in touch

Expertise

Trusted Software Excellence across Desktop and Embedded

Take a glance at the areas of expertise where KDAB excels ranging from swift troubleshooting, ongoing consulting and training to multi-year, large-scale software development projects.

Find out why customers from innovative industries rely on our extensive expertise, including Medical, Biotech, Science, Renewable Energy, Transportation, Mobility, Aviation, Automation, Electronics, Agriculture and Defense.

Embedded Devices Embedded Devices

High-quality Embedded Engineering across the Stack

To successfully develop an embedded device that meets your expectations regarding quality, budget and time to market, all parts of the project need to fit perfectly together.

Learn more about KDAB's expertise in embedded software development.

Read More

Cross-platform Desktop Cross-platform Desktop

Create complex Applications for the Desktop

Where the capabilities of modern mobile devices or web browsers fall short, KDAB engineers help you expertly architect and build high-functioning desktop and workstation applications.

Read More

Modernizing Legacy Software Modernizing Legacy Software

Reduce Technical Debt

Legacy software is a growing but often ignored problem across all industries. KDAB helps you elevate your aging code base to meet the dynamic needs of the future.

Whether you want to migrate from an old to a modern GUI toolkit, update to a more recent version, or modernize your code base, you can rely on over 25 years of modernization experience.

Read More

Medical Medical

Extensible, Safety-compliant Software for the Medical Sector

Create intelligent, patient-focused medical software and devices and stay ahead with technology that adapts to your needs.

KDAB offers you expertise in developing a broad spectrum of clinical and home-healthcare devices, including but not limited to, internal imaging systems, robotic surgery devices, ventilators and non-invasive monitoring systems.

Read More

Industrial Industrial

Build on Advanced Expertise when creating Modern UIs

KDAB assists you in the creation of user-friendly interfaces designed specifically for industrial process control, manufacturing, and fabrication.

Our specialties encompass the custom design and development of HMIs, enabling product accessibility from embedded systems, remote desktops, and mobile devices on the move.

Read More

Vehicle Dashboards Vehicle Dashboards

Fluid animations and gesture-controlled UIs

Building digital dashboards and cockpits with fluid animations and gesture-controlled touchscreens is a big challenge.

In over two decades of developing intricate UI solutions for cars, trucks, tractors, scooters, ships, airplanes and more, the KDAB team has gained market leading expertise in this realm.

Read More

Security and Defense Systems

Reliable software for the public security and defense sector

KDAB is a trusted software partner for authorities and suppliers requiring ever more robust and reliable software in the public security and defense sector. 

Read More

Services

Software Consulting, Development and Training

KDAB offers a wide range of services to address your software needs including consulting, development, workshops and training tailored to your requirements.

Our expertise spans cross-platform desktop, embedded and 3D application development, using the proven technologies for the job.

Software Consulting Software Consulting

Guidance for your Software Project across the Stack

Get expert advice on any phase of your project's journey, from inception to execution, across multiple platforms and hardware.

KDAB provides guidance on architectural approach, UI strategy, development tooling, test infrastructure, deployment model, runtime execution and more.

Read More

Code Modernization

UI Modernization

CI/CD

Performance optimization

Software Architecture

Migration from legacy frameworks

Qt Services Qt Services

Expert Qt Solutions for Your Needs

When working with KDAB, the first-ever Qt consultancy, you benefit from a deep understanding of Qt internals, that allows us to provide effective solutions, irrespective of the depth or scale of your Qt project.

Qt Services include developing applications, building runtimes, mixing native and web technologies, solving performance issues, and porting problems.

Read More

Qt 5 to Qt 6 Migration Services

Embedded Development Embedded Development

Build rich embedded applications for your embedded UI

Turn your vision into reality and unleash the potential of your embedded development projects.

KDAB helps you navigate the complex landscape of embedded development, ensuring your software performs optimally on your chosen hardware.

Read More

Cross-platform Development Cross-platform Development

Get help with all Aspects of Desktop Applications

KDAB helps create commercial, scientific or industrial desktop applications from scratch, or update its code or framework to benefit from modern features.

Discover clean, efficient solutions that precisely meet your requirements.

Read More

3D Software 3D Software

Simplify the complexity of 3D

Creating 3D applications can be overwhelming due to terminology, visual concepts, and advanced math.

KDAB simplifies this task, providing you with the best solution for your 3D project, easing complexities and maximizing efficiency.

Read More

OpenGL Expert Services

Vulkan

Developer Training Developer Training

Professional Developer Training Courses

Boost your team's programming skills with in-depth, constantly updated, hands-on training courses delivered by active software engineers who love to teach and share their knowledge.

Our courses cover Modern C++, Qt/QML, Rust, 3D programming, Debugging, Profiling and more.

Read More

Technologies

Make the right Technology Choices

The collective expertise of KDAB's engineering team is at your disposal to help you choose the software stack for your project or master domain-specific challenges.

Our particular focus is on software technologies you use for cross-platform applications or for embedded devices.

Qt / QML Qt / QML

Leading Qt Expertise

Since 1999, KDAB has been the largest independent Qt consultancy worldwide and today is a Qt Platinum partner. Our experts can help you with any aspect of software development with Qt and QML.

Read More

Modern C++ Modern C++

Deep understanding of Modern C++

KDAB specializes in Modern C++ development, with a focus on desktop applications, GUI, embedded software, and operating systems.

Our experts are industry-recognized contributors and trainers, leveraging C++'s power and relevance across these domains to deliver high-quality software solutions.

Read More

Rust Rust

Integrate Rust into your application

KDAB can guide you incorporating Rust into your project, from as overlapping element to your existing C++ codebase to a complete replacement of your legacy code.

Read More

How to build Hybrid Rust and C++ Applications

Memory-Safety Roadmap for Secure Programming

Platforms Platforms

Unique Expertise for Desktop and Embedded Platforms

Whether you are using Linux, Windows, MacOS, Android, iOS or real-time OS, KDAB helps you create performance optimized applications on your preferred platform.

Read More

Windows

MacOS/iOS

QNX

Unix / X11 (Motif)

Android

Web Engines

Linux

Embedded Linux

Slint Slint

A lightweight GUI toolkit

If you are planning to create projects with Slint, a lightweight alternative to standard GUI frameworks especially on low-end hardware, you can rely on the expertise of KDAB being one of the earliest adopters and official service partner of Slint.

Read More

Flutter Flutter

Flutter for Embedded and Desktop

KDAB has deep expertise in embedded systems, which coupled with Flutter proficiency, allows us to provide comprehensive support throughout the software development lifecycle.

Our engineers are constantly contributing to the Flutter ecosystem, for example by developing flutter-pi, one of the most used embedders.

Read More

3D / OpenGL / Vulkan 3D / OpenGL / Vulkan

Cutting-edge 3D / XR

Incorporating 3D into 2D UIs or creating compelling XR experiences can be challenging.

Create visually stunning, ultra-realistic 3D graphics, dynamic 2D user interfaces, or leveraging the power of hardware-accelerated computation.

The 3D experts at KDAB bring incisive know-how for your project.

Read More

Qt 3D

Vulkan – next generation graphics & compute

OpenGL expert services

Developer Tools Developer Tools

Developer Tools from KDAB

The right tools and libraries can skyrocket developers' productivity.

Take advantage of KDAB's popular open source tools for tasks including profiling, debugging and continuous integration (CI).

Read More

GammaRay

KD Reports

KD Chart

Hotspot

KD SOAP

KDDockWidgets

KDAB Labs KDAB Labs

Research & Development at KDAB

KDAB invests significant time in exploring new software technologies to maintain its position as software authority. Benefit from this research and incorporate it eventually into your own project.

Read More

KDGpu

Resources

Start here to browse information on the KDAB website(s) and take advantage of useful developer resources like blogs, publications and videos about Qt, C++, Rust, 3D technologies like OpenGL and Vulkan, the KDAB developer tools and more.

Blogs Blogs

KDAB engineers and designers constantly share cutting-edge technology insights with regard to Qt, QML, C++, Rust, Linux, Vulkan, OpenGL, Qt 3D, scalable UIs and more topics.

Stay up-to-date and be inspired with their blogs.

Read More

Events Events

Get a quick overview of events relevant to the software industry and with involvement of KDAB, be it as speakers, sponsors, exhibitors or organizer.

Take the opportunity to reach out to our experts directly. See you there!

Read More

Publications Publications

KDAB regularly publishes in-depth papers, brochures and other material on topics relevant to software developers and desicion makers.

Have a look at the list of KDAB publictions.

Read More

Videos Videos

The KDAB Youtube channel has become a go-to source for developers looking for high-quality tutorial and information material around software development with Qt/QML, C++, Rust and other technologies.

Click to navigate the all KDAB videos directly on this website.

Read More

Why KDAB

A software supplier you can rely on

In over 25 years KDAB has served hundreds of customers from various industries, many of them having become long-term customers who value our unique expertise and dedication.

Learn more about KDAB as a company, understand why we are considered a trusted partner by many and explore project examples in which we have proven to be the right supplier.

About KDAB About KDAB

Committed, compassionate, trustworthy

The KDAB Group is a globally recognized provider for software consulting, development and training, specializing in embedded devices and complex cross-platform desktop applications.

Read more about the history, the values, the team and the founder of the company.

Read More

Proven Excellence Proven Excellence

Customer Success Stories

When working with KDAB you can expect quality software and the desired business outcomes thanks to decades of experience gathered in hundreds of projects of different sizes in various industries.

Have a look at selected examples where KDAB has helped customers to succeed with their projects.

Read More

Trusted Partner Trusted Partner

Benefit from a strong partner network

Lasting relationships reduce frictions in software development projects and help to guarantee success.

Benefit from the established relationships KDAB has with well-selected hardware suppliers and specialized domain experts.

Read More

Software Excellence for Texas Instruments

Better Software Better Software

Constantly improving Software Quality

KDAB is committed to developing high-quality and high-performance software, and helping other developers deliver to the same high standards.

We create software with pride to improve your engineering and your business, making your products more resilient and maintainable with better performance.

Read More

ISO 9001 ISO 9001

ISO 9001 certified software services

KDAB has been the first certified Qt consulting and software development company in the world, and continues to deliver quality processes that meet or exceed the highest expectations.

Read More

Working at KDAB Working at KDAB

Looking for a new challenge?

In KDAB we value practical software development experience and skills higher than academic degrees. We strive to ensure equal treatment of all our employees regardless of age, ethnicity, gender, sexual orientation, nationality.

Interested? Read more about working at KDAB and how to apply for a job in software engineering or business administration.

Read More

Contact

Search

CODEBROWSER

KDAB|Training