Open-source project
u-boot/u-boot avatar
u-boot/u-boot

U-Boot: a defconfig per board, a sandbox for the host, and a maintainer script for the blame

"Das U-Boot" Source Tree

5,334 stars4,789 forksCNOASSERTION

At a glance

What is it?
Das U-Boot is a boot loader for embedded PowerPC, ARM, MIPS and other processor boards, written in C and configured one board at a time. The tree is at version 2027.01-rc1, and the interesting parts are the defconfig targets, the sandbox board, and the file that tells you who owns a board.
Who is it for?
U-Boot fits embedded developers who have a board, a toolchain and a reason to own the first instructions the processor runs, and who will treat `make <board_name>_defconfig`, the MAINTAINERS data and the sandbox board as the three levers that matter. It does not fit a quick experiment: the sandbox is for work that is not board specific, a vanished board config is a dead end recorded only in `doc/README.scrapyard`, and there is no release feed to subscribe to.
Can I use it commercially?
Check first. The repository uses a licence we do not classify automatically, so read its LICENSE file before any commercial use.
Is it still maintained?
Yes. The repository last received commits 2 days ago.
What is it written in?
Mainly C, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • u-boot/u-boot5,334 ★ · +84
Star history
Repository2026-09-232026-11-15
u-boot/u-boot5.3k5.3k

84 Stars in the last 53 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

The board name in the make target picks your whole configuration

Configuration in U-Boot starts with a board name, not a vendor or a chip family. Every supported board has a ready-to-use default configuration, and you select it with `make <board_name>_defconfig`. The worked example in the project documentation is a TQM823L module:

bash
cd u-boot
make TQM823L_defconfig

Everything downstream of that choice is yours, and the project is direct about how much the choice buys you. A board with a default configuration file in the `configs/` directory has been tested to some extent and is considered working, and many such boards are used in production systems. Tested to some extent is not the same as certified, so read the word as a baseline rather than a promise.

The failure mode is concrete as well. If you are looking for the default configuration of a board you expected to find and it is no longer there, the answer sits in `doc/README.scrapyard`, a list of boards no longer supported. From there the project routes the rest of the work: `scripts/get_maintainer.pl <path>` identifies the people or companies responsible for a board or a subsystem, and the git log shows the recent history. Read both before you start editing a board you did not write.

Four spellings, and getting one wrong is permanent in the tree

U-Boot is fussy about names and states the rules outright. The official name is 'Das U-Boot', while written text, meaning documentation and comments in source files, is to use the spelling 'U-Boot'. File names are based on the string 'u-boot', for example:

code
	#include <asm/u-boot.h>

Variable names and preprocessor constants are based on 'u_boot' or 'U_BOOT':

code
	U_BOOT_VERSION		u_boot_logo
	IH_OS_U_BOOT		u_boot_hush_start

One project, four forms, and the split is not cosmetic: the same names have to hold across documentation, source comments, file names and identifiers at the same time. The practical effect is on everything you add. A new file called u_boot.h, a constant named IH_OS_U_BOOT, or a comment that spells the project Uboot all sit outside the convention, and the project lists no exception to it. Since file names under `include/` and the symbols other people copy out of board code are the parts that spread, a mistake here outlives the patch that introduced it.

The sandbox board runs the monitor on your own Linux host

U-Boot can be built natively to run on a Linux host using the sandbox board. It exists so that feature development which is not board or architecture specific can be done on a native platform, and so that some of U-Boot's tests can run there. The details live in `doc/arch/sandbox/sandbox.rst`.

The README then lists options that need to be configured, starting with two that must be defined exactly once each, a CPU type such as `CONFIG_MPC85XX` and a board type such as `CONFIG_MPC8540ADS`. The rest split into 85xx CPU options, generic CPU options, ARM options and the Linux kernel interface. The dependencies are the interesting part. `CONFIG_SYS_PPC64` marks a 64-bit PowerPC implementation and is needed for ePAPR compliance among other reasons. `CONFIG_SYS_FSL_ERRATUM_A004510` enables a workaround for erratum A004510, and if it is set, `CONFIG_SYS_FSL_ERRATUM_A004510_SVR_REV` (with `_SVR_REV2` optional) and `CFG_SYS_FSL_CORENET_SNOOPVEC_COREONLY`, the value written into CCSR offset 0x18600, must be set.

code
	CONFIG_SYS_PPC64
	CONFIG_SYS_FSL_ERRATUM_A004510
	CONFIG_SYS_FSL_ERRATUM_A004510_SVR_REV
	CFG_SYS_FSL_CORENET_SNOOPVEC_COREONLY
	CONFIG_SYS_FSL_DDR
	CONFIG_OF_LIBFDT

The two ARM timer options, `COUNTER_FREQUENCY` and `COUNTER_FREQUENCY_REAL`, exist as a pair because the real clock can differ from the configured one and only be determined at run time. And note what sandbox is not for: by construction it covers work that is not board specific, so a driver that exists for one piece of silicon still needs the hardware.

A maintainer script and a mailing list archive stand in for a support desk

Support in U-Boot is organised by ownership rather than by a queue. When something is broken, the project points you at `scripts/get_maintainer.pl <path>` to identify the people or companies responsible for boards and subsystems, and at the git log as the other source. The tree carries that ownership data in files: `MAINTAINERS`, `.get_maintainer.conf`, `.get_maintainer.ignore`, `.mailmap` for name normalisation and `.patman-defaults` for the patch workflow.

Questions and contributions go to the mailing list at [email protected], and the instruction is explicit about ordering: search the archive before asking, at https://lists.u-boot-project.org/pipermail/u-boot or https://marc.info/?l=u-boot. That advice shapes what a newcomer meets. The named support channel is a mailing list, and the first place the project tells you to look is an archive of earlier traffic, so the answer to the question you are about to ask may already be in an old thread. Quality is enforced mechanically elsewhere: continuous integration lives in `.gitlab-ci.yml`, `.gitlab-ci-sage-lab.yml` and `.azure-pipelines.yml`, and patch style rules sit in `.checkpatch.conf` and `.clang-format`.

The Makefile disables make's own rules and pins collation to C

The top-level Makefile is where the build conventions become visible. The version is spelled out in variables: `VERSION = 2027`, `PATCHLEVEL = 01`, an empty `SUBLEVEL`, and `EXTRAVERSION = -rc1`, which makes the tree a release candidate rather than a final release.

makefile
VERSION = 2027
PATCHLEVEL = 01
SUBLEVEL =
EXTRAVERSION = -rc1
NAME =

Build behaviour is deliberate in three ways. Internal targets are prefixed with `__`, and asking for one raises an error, because such targets are only for internal use. Make's built-in rules and variables are switched off with `MAKEFLAGS += -rR`, which the file justifies as a performance gain that also avoids hard to debug behaviour. The environment is neutralised too: `LC_ALL` is unexported, `LC_COLLATE` and `LC_NUMERIC` are set to `C` and exported, and `GREP_OPTIONS` is unexported.

The comment block above those lines explains the recursive build. Sub-Makefiles should only modify files in their own directory; when one depends on a file in another directory, the build calls a sub make there and waits for it to be up to date, and the cases with global effects are pulled out ahead of the descent into the prepare rule. `make help` lists the targets, and `Kbuild`, `Kconfig` and `config.mk` sit at the top level next to the `board/`, `cmd/`, `drivers/`, `dts/`, `fs/`, `net/` and `test/` trees.

No release feed: tarballs come from tags or the DENX file server

Two things about distribution matter before you plan an integration. First, this repository publishes no GitHub releases. The canonical source is the Git repository at https://git.u-boot-project.org/u-boot/u-boot.git, browsable at https://git.u-boot-project.org/u-boot/u-boot, and the Tags links on that page are how a tarball of any version is downloaded. Official releases are also served from the DENX file server over HTTPS at https://ftp.denx.de/pub/u-boot/ and over FTP at ftp://ftp.denx.de/pub/u-boot/. Anything that watches a release feed has to watch tags instead.

Second, licensing is spread across files, which matters when a build has to report provenance. The README header carries `SPDX-License-Identifier: GPL-2.0+` and attributes copyright from 2000 to 2013 to Wolfgang Denk of DENX Software Engineering, while `COPYING` and a `Licenses/` directory sit at the top of the tree. The repository's own license field is unresolved, so the SPDX tag alone is not the whole answer.

The history explains the layout. The code started from 8xxrom sources, became the PPCBoot project, was cleaned up and extended to other PowerPC CPUs with an extended interface to the Linux boot loader, S-Record download, network boot and ATA or SCSI boot, then became ARMBoot before the name settled on U-Boot, with the project page at https://www.denx.de/wiki/U-Boot. Development on main continued up to a push dated 2026-11-02.

Editorial conclusion

U-Boot fits embedded developers who have a board, a toolchain and a reason to own the first instructions the processor runs, and who will treat `make <board_name>_defconfig`, the MAINTAINERS data and the sandbox board as the three levers that matter. It does not fit a quick experiment: the sandbox is for work that is not board specific, a vanished board config is a dead end recorded only in `doc/README.scrapyard`, and there is no release feed to subscribe to. Before you build, confirm your board still has a defconfig target, read the option dependencies for the SoC you target, and decide which version string you are pinning, since the tree currently carries 2027.01-rc1.

Frequently asked questions

What does U-Boot stand for?

The official name of the project is Das U-Boot. Written text uses the spelling U-Boot, file names are based on the string u-boot, and variable names and preprocessor constants are based on u_boot or U_BOOT.

Is U-Boot a bootloader?

Yes. It is a boot loader for embedded boards based on PowerPC, ARM, MIPS and several other processors, and it can be installed in a boot ROM and used to initialize and test hardware or to download and run application code.

How does U-Boot work?

You pick a board with its default configuration, for example make TQM823L_defconfig, and everything downstream follows from that choice. For work that is not board or architecture specific, the sandbox board builds natively to run on a Linux host, where some of the tests run as well.

What is U-Boot's relationship to Linux?

The development is closely related to Linux: parts of the source code originate in the Linux source tree, some header files are in common, and special provision has been made to support booting of Linux images. The Linux kernel interface is configured through options such as CONFIG_OF_LIBFDT.

Official sources

  1. Issues
  2. README
  3. u-boot/u-boot on GitHub
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/u-boot-u-boot.svg)](https://hysenlabs.com/projects/u-boot-u-boot)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/u-boot-u-boot.svg)](https://hysenlabs.com/projects/u-boot-u-boot)

Was this useful?