2 November 2026
Article published by: Leah Rowe in GNU Leah Mode
Date of publication: 2 November 2026
You can find today’s release in https://rsync.canoeboot.org/26.11rev12/ or you can use one of the mirrors.
Canoeboot is free, libre boot firmware replacing proprietary BIOS/UEFI firmware on supported Intel/AMD and ARM64 hardware. It initialises the hardware inside your computer such as the CPU or memory controller, configuring the machine in such a way as to enable use of an operating system at boot. Canoeboot offers greater security and customisation compared to proprietary firmware; its goal, plainly, is to rid the world of proprietary software and to do that, we therefore try to provide firmware that is extremely easy for non-technical users to understand.
Today’s release changelog is relative to the previous Canoeboot 26.01 release.


First thing’s first. (and yes, you read the previous paragraph correctly)
A strongly anti-AI policy was added to a new file: AGENTS.md in cbmk. This is the most important change in the release. Now everything else:
Not added in this release - yet.
It’s possible that we can have from Intel SandyBridge, IvyBridge all the way up to Haswell in a future release, as native raminit and video initialisation is available on these boards; the EC firmware could be built from source quite easily.
NOTE: The EDK2 payload was added in this release, for Intel/AMD boards in Canoeboot that are able to use it. Our very own free distribution of EDK2.
Please note: coreboot (upstream) has patches under review at the time of this release, freeing the Intel FSP on Intel Kabylake hardware. This means that a future release of Canoeboot will likely contain support for Kabylake Chromebooks as well.
E.g. KGPE-D16. We use the coreboot fork from 15h.org now, on AMD Fam15h mainboards. This uses AMD AGESA source code instead of Timothy’s custom init code. It has much more reliable raminit and CPU initialisation; more RAM also supported. Many bugs are fixed. IOMMU works, I also saw that they mentioned TPM is fixed in their version, now our version also.
Regular binaries with SeaBIOS and GRUB payloads provided, with GRUB provided via SeaGRUB configuration.
Basically, these boards actually work for the first time.
Canoeboot now provides its own free distribution of EDK2, for UEFI boot on Intel/AMD 64-bit hardware.
The following boards now have an EDK2 UEFI payload available:
dell_latitude_e4300_4mbdell_latitude_e5420_6mbdell_latitude_e5520_6mbdell_latitude_e5530_12mbdell_latitude_e6230_12mbdell_latitude_e6330_12mbdell_latitude_e6400_gpu_intel_4mbdell_latitude_e6430_12mbdell_latitude_e6530_12mbdell_latitude_e7240_12mbdell_optiplex_7010_sff_12mbdell_optiplex_780_mt_8mbdell_optiplex_780_mt_truncate_8mbdell_optiplex_780_usff_8mbdell_optiplex_780_usff_truncate_8mbdell_optiplex_9020_mt_12mbdell_optiplex_9020_sff_12mbdell_precision_t1650_12mbhp_elite_8300_cmt_16mbhp_elite_8300_usdt_16mbhp_pro_3500series_8mblenovo_thinkpad_r400_16mblenovo_thinkpad_r400_4mblenovo_thinkpad_r400_8mblenovo_thinkpad_r500_4mblenovo_thinkpad_t400_16mblenovo_thinkpad_t400_4mblenovo_thinkpad_t400_8mblenovo_thinkpad_t430_12mblenovo_thinkpad_t440p_12mblenovo_thinkpad_t500_16mblenovo_thinkpad_t500_4mblenovo_thinkpad_t500_8mblenovo_thinkpad_t530_12mblenovo_thinkpad_w500_16mblenovo_thinkpad_w500_4mblenovo_thinkpad_w500_8mblenovo_thinkpad_w530_12mblenovo_thinkpad_w541_12mblenovo_thinkpad_x200_16mblenovo_thinkpad_x200_4mblenovo_thinkpad_x200_8mblenovo_thinkpad_x230_12mblenovo_thinkpad_x230t_12mblenovo_thinkpad_x301_16mblenovo_thinkpad_x301_4mblenovo_thinkpad_x301_8mbThese next targets only have EDK2 and iPXE, but do not include a GRUB or Memtest86+ EFI binary due to limited CBFS size (standalone GRUB and SeaBIOS images are still available):
hp_elite_8200_sff_8mb - this has EDK2-only images and GRUB images, butlenovo_thinkpad_t420_8mb - dittolenovo_thinkpad_t420s_8mb - dittolenovo_thinkpad_t520_8mb - dittolenovo_thinkpad_x220_8mb - dittoThese targets only have the older SeaBIOS and GRUB setups, as the CBFS size is 2MB and not big enough for EDK2:
dell_latitude_e6220_10mb - this and the ones below have 2MB CBFSdell_latitude_e6320_10mb - it’s just about too small - about 100kb biggerdell_latitude_e6420_10mb - 100kb bigger than available in CBFS heredell_latitude_e6520_10mb - (2MB BIOS region on these latitudes)TODO: Perhaps strip out the UEFI shell for systems with 2MB flash. Then it will probably fit in 2MB.
Other targets (e.g. ThinkPad X60, T60, D945GCL5, MacBook1,1, 2,1) are either 32-bit-only or have insufficient flash capacity for EDK2. NOTE: Even where EDK2 is available, the legacy SeaBIOS/GRUB setups are also still available, but UEFI will be Canoeboot’s preferred payload (via EDK2) in this and future releases.
EDK2 is Intel’s reference implementation of the UEFI specification, for booting. It’s typically used by vendors, in proprietary forks of Intel’s BSD-licensed code, but Intel’s reference code is Free Software. We use their reference code, and full source code is provided in this Canoeboot release. EDK is short for: EFI Development Kit.
More specifically:
We use a fork of Intel’s reference code, which specifically offers use of EDK2 as a generic coreboot payload. This is a complete, industry-standard UEFI implementation capable of booting any compliant operating system.
All. Nearly all boards use it in Canoeboot now, even older ones e.g. ThinkPad X200. Tested on all platforms. Older, 32-bit-only mainboards still use the setup from the previous release, while virtually all 64-bit-compatible hardware now use EDK2. EFI builds of GRUB and SeaBIOS are provided in flash, accessible from the EDK2 setup menu (press ESC at boot time when prompted), for backward compatibility with existing installations in Canoeboot.
Several Canoeboot boards now use an libre UEFI implementation by default, where feasible. All of them, and it’s by default - the bare metal GRUB and SeaBIOS coreboot payloads have been removed, replaced by EFI versions that are backward compatible.
We previously did not provide UEFI at all, except for U-Boot on a few select mainboards. We now provide full UEFI, with all four freedoms intact, on nearly every mainboard that Canoeboot supports.
Modern computers and operating systems are all UEFI, and this new setup can boot basically all of it reliably. More testing will be required, but this is battle-tested code and it has been used extensively in coreboot by many users, for many years. Canoeboot finally has it as well.
This change alone is part of a much wider effort to modernise Canoeboot, and I’m only getting started. The next Canoeboot releases will draw heavily on this, as EDK2 is pretty much the expected payload on a lot of modern coreboot setups these days. Integration of EDK2 removes all limitations in Canoeboot, allowing us to support much newer hardware and it basically makes Canoeboot much easier to use; I expect Canoeboot to become much more popular and useful over time, as a result.
Some caveats and extra notes are provided at the end of this release page, for migration purposes. For example, despite boasting about all, older 32-bit-only hardware still use bare GRUB/SeaBIOS. Nearly all boards use EDK2 however!
Please look first at extras for notes about use of the onboard GPU e.g. Intel GPU, offloading rendering to a graphics cards. In some cases, this can be used instead, avoiding the need to actually run an option ROM on your graphics card. Canoeboot generally recommends use of integrated graphics as free initialisation is provided by Canoeboot, but some users may wish to use graphics cards anyway. It is not the policy of Canoeboot to break the user’s machine, where it can avoid distributing blobs in the process, but please know for all certainty: graphics cards have option ROMs on them that software like SeaBIOS and EDK2 can scan and execute at boot time, to initialise a framebuffer for the card. This is then used by drivers in operating systems. The purpose of Canoeboot is to provide the user only free software, and only steer them towards it, but lots of people want to use graphics cards regardless, so Canoeboot makes a point of ensuring that these also work, while providing warnings such as these.
Finally, some notes about graphics cards that may be of interest to the more demanding users.
EDK2 alongside PCI-E relocatable BAR (rebar) means that you can now use modern graphics cards that require allocations above 4GB. Rebar is not enabled by default, but you can enable it in menuconfig (coreboot). Enabling it causes breakage of Intel GPU video output on libgfxinit in testing, and no fix was found yet, so rebar is disabled by default.
PCI-E Option ROMs are enabled by default where necessary, for EDK2 builds. This means you can use it on desktops with graphics cards. Tested on several desktops (Dell OptiPlex 9020 SFF and 5050 SFF).
On boards with only external GPU, rebar can be left enabled by default. On systems with functioning integrated graphics, accidental enablement of rebar can be remedied by inserting a graphics card; when the video output in the payload does become broken, the Linux i915 video driver still initialises video framebuffer properly in KMS/DRM.
This will be added to general documentation, pending fixes upstream. Note that even with this issue, Linux video output works fine. This will be corrected and rebar enabled by default, on a future Canoeboot release.
Nearly all major upstream revisions updated:
4.11_branch tree) and replaced with:4.11_branch, for improved initialisation reliability on AMD FAM15H hardware e.g. ASUS KGPE-D16.The 4.11_branch tree of coreboot was removed, because we now use the 15h.org fork of coreboot on AMD Fam15h hardware. This is much improved, with proper AGESA-based initialisation which initialises CPUs and memory controller more reliably. More RAM is supported, and several features were fixed too e.g. IOMMU and TPM.
The use of multiple coreboot upstreams was enabled by a design improvement in cbmk that makes all projects multi-tree, just with some projects ony having one tree in use. We can have N number of upstreams per project now, enabling use of forks.
The coreboot update brings in GCC 15.2, MPC 1.4.1, Nasm 3.02, acpica 20251212 and binutils 2.46.1 on crossgcc.
No new hardware was added in this Canoeboot release, but a lot of interesting features have been added to pre-existing hardware that Canoeboot supports.
This is very much a features release. A lot of feature changes were made!
fwsetup command in a GRUB menuentry on the EFI version, which boots back into the edk2 setup menu.at_keyboard driver: always force scancode set 2 with translation. This was already done, but only on the coreboot target; it is now also done on the EFI target, by just applying it universally to all targets. This is because it’s possible to use it with PS/2 keyboards on EDK2. It mitigates buggy PS/2 controllers that might not report modes correctly even when set, as on the Dell Latitude E6400../mk test command which aggressively builds everything, much more than even ./mk release - it intentionally disables use of caching, so that downloads are aggressively tested as well. Config-related commands are also tested. This is a brutal stress test command used to find build errors.--workaround-mx option is retained, but no longer does anything as its behaviour is always applied. This improves general reliability as a lot of users don’t know about this option anyway. More people can reliably flash their boards now.-c and x (clean and xgcc-clean) flags in cbmk, as they are largely superfluous; cbmk already auto-cleans everything before build anyway, to remove all build artifacts, and aggressively caches builds out of tree based on config metadata, deleting and re-fetching sources from local cache as required. These options were useless.A lot of major design changes have been made!
XBMK_CACHE as it’s now hardcoded in config. The new handling is much stricter, and less likely to regress in future revision. This was done to reduce the possibility of a directory escape bug in cbmk.--mirror git clones on include/env/get.sh. This makes cloning revisions more reliable on all projects, especially ones where we use revs inside branches other than main.custom_ prefix is not used in image file names. Proper edk2 prefix is used.noconfig variable that can be set by build trees/targets, where they are multi-tree but no configs are used. This makes it appear under a fake name called noconfig, e.g. elf/grub/default/efi/noconfig/grub.elf when compiled.get.sh: use -L in find command, because some projects now use symlinks to metadata from other projects to ensure rebuilds. For example, edk2 coreboot targets (dummy targets) rely on grub and seabios efi builds. When these builds have to change, we need to ensure that the edk2 coreboot build is re-done. Here, we mean the find command used for finding files to hash when checking whether a given project has changed in build system setup.get.sh.get.sh: support arbitrary submodule config path, for projects that use multiple versions of a submodule. For instance, EDK2 uses multiple versions of brotli.make distclean on projects before building, made feasible due to Canoeboot’s aggressive out-of-tree caching of project builds based on metadata checks in cbmk.noconfig=n on a project, which allows it to be multi-tree and use the same tree on different targets, even when build configs aren’t required; in some cases, configs are done exclusively in mkhelper settings. This is part of Canoeboot’s decision to make all projects multi-tree, alongside allowing use of N upstreams per project instead of just one upstream.release=n handling in cbmk; don’t execute mkhelpers. Skip source fetches if release=n, so that the corresponding source won’t be downloaded.init.sh: Portable date usage; git’s own date handling now used. We no longer rely on GNU-specific extensions to the date command, for git repository initialisation on release builds.mk from outside the main work directory. The build system now changes work directory accordingly.get.sh - this enables easier updates on project revisions.me_state to Disabled by default, tree-wide in coreboot (default tree). We already set the HAP bit in IFD anyway, but this is an extra layer of disablement, to make sure that the Intel ME is deader than dead.-Werror on all projects, where feasible.97dbfd3098ae12ef3f51e5f95cd6d66c25214205. This revert was done by HustlerOne in their new Snowboot project, and copied from Snowboot into the Canoeboot project../mk -s seabios which never saves a defconfig file.src/gpio-scripts due to unclear licensing on the version used. (no license given on the changes to it, forked to standalone from coreboot where it fell back to coreboot’s COPYING file, but the fork repo did not have any licensing in it whatsoever - what changes were made was also unclear as a result).mk when resolving trees/revisions in projects. Trees that refer to other trees infinitely are now detected.std=gnu2x on coreboot/default instead of std=gnu23; gnu2x is code compatible with gnu23 on newer GCC versions, but older versions used in e.g. 2024 distros.make when if_skip_build is set in the main mk script, for more thorough mkhelper execution on all projects.command -v usage in a few places when setting up cbmk.x_ in mk, wrapping xbmk_init. The latter never returns non-zero status, so this fix is purely preventative in case the function is ever redesigned at some point to do that.shift which allows for proper double-quoting to be handled.__unused variables and cast them to (void) instead, where unused, to prevent build errors in GCC 16.A lot of changes were made to util/nvmutil/ to the extent that it deserves its own release log:
-pedantic flag - also remove this on spkmodem-recv. Reduces the chance of pedantic build errors based on warnings.close() if function returns with error (EINTR on close is not an error condition in POSIX, and the descriptor should be disregarded in such scenario).read, write,preadandpwrite` - EINTR-safe, with stricter (than libc) checks against incomplete writes and such.NOTE: This applies to the standalone version of nvmutil. There was an attempt to rewrite it in a much larger utility, mentioned in the following section about canceled changes for this release.
Roughly one thousand lines of dead code were cleaned out of the build system, but several hundred more were added due to new feature changes. Overall, the amount of code in cbmk has been reduced, in spite of its advances in this release.
Specific cleanup includes:
config/ centralised better, e.g. config/module/coreboot/ instead of config/coreboot. The directory config/ifd/ is moved to config/data/coreboot/ifd/ as it’s only ever used from coreboot.config/ directory is generally better organised now, with more unified placement of files per-project.forx function allows macro-like shorthand for loops, greatly simplifying much of the code.lib.sh: Made build_sbase function a macro instead, so that it can be changed all in one place. It’s literally just one command (make -C util/sbase).add_uboot logic as it is only needed now for ARM64. The conditional logic for x86 was removed as we no longer use U-Boot on x86 at all; EDK2 is now the preferred payload on x86, for UEFI.release.sh: Removed the -m option as it’s useless. There is no context in which we want to generate a source archive without also building binaries. What’s the point in doing half a release? This is dead code. Knobs are for nobs.awk heavily in certain parts of the build system, to further unroll a few loops, especially in the err function.findpath function in mk. It’s now one line of code, using forx. (wrapper function for readlink -f and realpath.xbmkpwd initialisation in mk.xprintf in mk; we now just printf ampersand into awk. Easy.xbmkpwd initialisation in mk; we now find the path to mk and cd to its base directory, which thus becomes xbmkpwd.xbmk_init from main script, not init.sh. This makes it clearer on first reading, where xbmk initialisation is called from. We do it just below the include of init.sh.tree.sh (later merged into mk) conditionally. Now absolutely all state is global, which enabled further code simplication and variable cleanup.get.sh considerably. A lot of logic, especially submodule handling, was aggressively generalised.Just two canceled works:
keymap.gkb in CBFS when booting with EDK2. This was canceled because a better method will be implemented post release; use of HiiDatabase and a graphical config menu in EDK2 to change the keyboard layout and locale. This will be written to SMMSTORE and also used by payloads. For example, the GRUB EFI payload could read from SMMSTORE to know locale and then change its language accordingly, using its existing gettext integration (GRUB already supports internationalisation).The ARM64 payload is still present, but EDK2 has replaced U-Boot on x86.
This deserves its own section, in this release, as it is a major design change. EDK2 was not merely added as an option; it has replaced U-Boot on x86. I could make this its own article. It deserves one. It deserves my judgement, publicly as I’m now about to articulate in no uncertain terms:
U-Boot was used for lightweight UEFI implementation on Intel/AMD boards, but the person chiefly in charge of the x86 coreboot payload for U-Boot has largely forked U-Boot into a newly vibe-coded project; Canoeboot opposes heavily the use of AI, as per new policy. AI is no good, and upstream x86 U-Boot support has largely bitrotted although several interesting patches were merged.
U-Boot is thus a liability on x86. EDK2 is more fully functional already, so this is used instead. Think AI makes you a super hacker? Think again:
U-Boot was always buggy on x86 anyway. It’s really just not ready at all. It is better used on RISCV and ARM64(where we continue to use it).
U-Boot upstream itself is staunchly anti-AI, at least at the time of this release, and much discussion of the above was had on their mailing list. It would not be productive to re-ligitate that on this release page, but it should suffice to say that the Canoeboot project considers U-Boot to be effectively dead on x86. The ARM-based development is still ongoing strongly, upstream, and we will continue to use U-Boot for UEFI on ARM64 (chromebooks for example).
I will not say his name, or the name of his fork, because I don’t want to promote him or his U-Boot fork. If you know his name or his project, you should not say it or promote it either. AI is bad, very bad, for reasons here:
The fork in question, of U-Boot, is heavily AI vibe-coded and thus useless to Canoeboot. This is not mere conjecture; in said aforementioned U-Boot mailing list thread, the author stated thus. We will not, in any way, encourage or facilitate use of AI. It has been made clear that several projects Canoeboot uses also have some AI-assisted commits; GCC, GRUB, etc. This is not our fault, but it is my intention that I and others will audit these projects in the future, de-slopping them and possibly even forking them entirely for that very reason. The author of the fork basically went insane with it, proposing to the U-Boot upstream that his work be “custodian”, and merged slowly into the upstream U-Boot tree. He was basically pressuring them to accept AI code against their wills. I say in my capacity as leader of the Canoeboot project that U-Boot should never allow AI to taint its project. When you accept AI, you become deskilled and you erode the trust that exists between you and your users. You remove the human connection between maintainers and users, and your project will start to become dependent on what is - yes - proprietary technology, paid for in blood. AI is one of the single biggest consumers of electricity and water on the planet, leading to resource shortages all over the world and its increasing control over what information people see in the news is even a threat to democracy worldwide. This is before even arguing about unclear licensing, copyright violations and so on. It was decided that Canoeboot would join the crusade against all artificial intelligence. The countries chiefly in charge of AI training and infrastructure are the United States (led by several companies currently attacking democracy worldwide) and the People’s Republic of China; even if all the other problems with AI didn’t exist, it would be a very bad idea to give these countries even more power over our computing.
NO. Canoeboot says no to AI. Thus, we will continue using upstream U-Boot as they say no also, and we will not use any vibecoded forks of it. Even if that causes me to have to spend weeks integrating a totally new system to replace it. That is precisely, exactly and indubitably how far I will go to prove my point.
That is why I went to such extreme effort integrating EDK2. Rather than replace U-Boot with yet another incomplete UEFI implementation, I simply added EDK2 which is already feature-complete as it is the reference, industry-standard implementation of the UEFI spec.
It was originally intended that U-Boot would become Canoeboot’s primary payload on x86, but alas. I bit the Intel-flavoured bullet and went with EDK2.
Say no to AI. AI makes you stupid. AI is the reason we can’t have nice things.
Images with edk2 in the file name are UEFI-based; 26.11rev10 and higher also prefix images with bios_ or uefi_ - U-Boot and EDK2 images are uefi_, while SeaBIOS and SeaGRUB images are bios_.
The plan initially was to make cbmk much simpler, thus EDK2-only on most boards. For the time being, Canoeboot will maintain dual configuration in this manner.
A new, more unified naming scheme was also introduced in revisions to the release, as above. For example, the arm64 images all say uefi_ but actually use U-Boot, not EDK2; U-Boot implements a subset of the UEFI specification, and it is the default payload on ARM64 Chromebooks. Intel/AMD targets with UEFI all use EDK2.
Bugs were found in the main release, later fixed, on legacy hardware where EDK2 was not used; here, we had standalone GRUB and SeaBIOS payloads. On setups with GRUB, some users reported broken keyboard input. This is because some machines need a timeout loop during PS/2 keyboard initialisation, and I’d overlooked this fact when making GRUB a standalone payload on legacy hardware.
I’ve thus made GRUB only available in the form of SeaGRUB once more. Images with GRUB now start SeaBIOS first.
Here is the full list of changes, from recent to oldest:
rom.sh: Avoid grep when scanning defconfigs, for more reliable operation as grep returns non-zero status on both file system error and logical error; now, we use a while read loop, and thus error handling is more reliably separated from syserror and logic error. This enables more fine-grained error control when processing config files.rom.sh: Always make image tarballs even when not building in release mode. This makes versioned builds easier to handle, if dealing with multiple versioned builds of the same mainboards.LOCALVERSION to coreboot builds, so that dmi strings would say canoeboot plus version number. This makes it easier for upstream projects to detect that someone is using Canoeboot when they send bug reports. This was done due to a complaint made by another coreboot project and rather than say all of what I wanted to say, I decided to honour their request. It just seemed like the right thing to do, as this affects all upstreams. It also means that Canoeboot now has a voice inside your DMI strings and inside the cbmem log, where it is also printed via printk.Minor cleanup:
at_keyboard and usb_keyboard modules. We don’t use these in EFI, because EDK2 handles everything.This is because release tarballs disable source fetching, by virtue of whether or not a CHANGELOG file is prevent - absent in the Git repository but generated in release archives.
Other changes:
_bios or _uefi at the name.Keymapped images were also re-added on the classic BIOS (SeaBIOS plus GRUB) targets; the EDK2 targets are still locked to only one keymap.
Reverted some defconfig changes that changed VBT path and SMBIOS vendor strings, to prevent build errors. I removed these, believing them to be redundant on a handful of boards, as they’d be defined in Kconfig. I’ve restored them, and also corrected them, e.g. Dell OptiPlex 780 variants now have correct board names in these strings.
Renamed more boards, for more consistent naming across all mainboards and platforms. Old target names are still compatible, in current revisions of 26.11, via backward compatibility features implemented in those revisions.
Renamed chromebook_ (rk3399) to cros_ in coreboot chromebook boards, for more consistent naming across different google products.
The new naming scheme is also more friendly to scripts (build systems).
Renamed cros rk3399 targets to match u-boot and coreboot target names. This affects gru bob/kevin chromebooks.
None of the changes from this rev were included (they were all for boards that Canoeboot does not support in this release).
Minor fixes and usability improvements:
mk: Errors now properly printed to stderr, where an error occurs in cbmk._bios or _uefi image sets. The same given target now has both types of images contained in each tar archive.bin/ as they are not intended for general use. Only the UEFIPAYLOAD.fd files from elf/ are used anyway, so to avoid confusing users, only the final real board build is provided in bin e.g. ThinkPad T480 build../mk inject commands, such that it works on tarballs from older Canoeboot releases. This is to mitigate the fact that the image names were changed heavily in this and other 26.11 revisions. Note once more: Canoeboot’s version of the inject script only does MAC address injection, so it’s only useful on IFD-based images with Intel GbE region for Intel gigabit ethernet configuration.Of note, this revision backports a major coreboot patchset from upstream:
Nicholas Chin has done extensive rework on battery handling for Dell Latitude models. It is no longer done in SMM. It is now done in a generalised ACPI framework, and existing S3 fixes are done there (patching to prevent DRAM from powering down in S3).
This patchset also adds support for battery status in EC, via the new ACPI patching. This means you can now monitor battery usage / charge level in ACPI-enabled operating systems.
The following features are still broken (and previously broken too), on Dell Latitudes:
The new EC handler code is more efficient, on Dell Latitudes. Doing it all in SMM violates one of coreboot’s main design criteria… putting everything in SMM is bloat. Doing it all in ACPI is just more performance-efficient, and easier to maintain. Note that these patches are still under review on the coreboot project, but they were deemed stable enough for a Canoeboot release.
The Canoeboot 26.11 release series has one extra dependency compared to the master branch of cbmk: 32-bit libc headers needed on 64-bit build hosts, for 32-bit memtest86+ builds.
Memtest86+ isn’t cross-compiled on cbmk, and not every distro will have 32-bit headers available for libc, so it’s 64-bit-only in cbmk master. 32-bit memtest is used on 32-bit-only hardware like ThinkPad X60, as a nice-to-have.
E.g. lib32-glibc package on Parabola.
Use of x86-64 is assumed, when building Canoeboot releases. We do also have 32-bit support, for building 32-bit machines on 32-bit hosts. For example, a Thinkpad X60 can be used to build X60 images in cbmk.
Please just make sure to have 32-bit libc headers available on 64-bit hosts when building the 26.11 release series - maintaining this dependency in the main branch is unacceptable, so cbmk would have to cross-compile payloads, which is in fact on TODO but not currently handled (cbmk uses host toolchains for nearly everything except coreboot and U-Boot, which are both compiled with crossgcc, but non-U-Boot payloads are built with the host toolchain).
Minor tweaks to RK3399 coreboot chromebooks (fix payload setup). Switching to defconfigs nuked CONFIG_PAYLOAD_NONE for some reason - more investigation needed, but rk3399 configs were switched back to full configs for now. This bug does not affect Intel/AMD boards, so they are still defconfig. Without this setting, cbmk’s payload insertion is skipped. This is a bug upstream that needs to be fixed, mitigated for now in this revision release.
Moved RK3399 chromebooks in coreboot to their own tree, for coreboot and u-boot, both trees named cros_arm.
Users are still recommended to use the new EDK2-based images. Note that the GRUB EFI and Memtest86+ EFI builds are still available in EDK2, and these do provide value. GRUB EFI especially, can be used to unlock encrypted /boot and bypass the need for an ESP, while still having an EFI runtime in the Linux distro of the user’s choice.
Fixed a critical remote code execution bug in EDK2, as reported by Intel’s Tianocore Security Advisory here:
https://github.com/tianocore/edk2/security/advisories/GHSA-99cj-7hg9-mp4m
NOTE: Not actually ever used when booting iPXE, so this bug never actually affected users, but the fix was merged anyway. We don’t want to ship with a known security bug.
An unchecked bound on incoming ICMP packets allowed attackers to send large packets during the PXE boot window, which could allow the ICMP buffer in EDK2 to overflow and, hence, the attacker could run unsigned code in an unprivileged context.
Tianocore released this patch to fix the CVE:
https://github.com/tianocore/edk2/pull/13302 - fixes CVE-2026-97631; users who did not boot with PXE were unaffected by this issue.
Fixed a hanging bug in EDK2 when booting operating systems via SD card on affected hardware. The fix is done by reverting a previous patch that forced eMMC probing as some soldered-down mmc flash may report itself as removeable; see notes in the patch, linked above. This patch was backported into Canoeboot EDK2, for the 26.11 release series.
Removed forx function in the build system, removed unused srclink variable, don’t use backticks on commands; general cleanup in the build system. More: removed trivial uses of eval and awk in the build system. The build_sbase macro is now a function.
Sources only cleaned before doing a build, to save on build time.
Simplified building of PCSX-Redux Open BIOS, by making use of the cpbin variable recently added to the Canoeboot build system.
Simplified building of serprog images by using cpbin instead of custom copy logic.
In get.sh, more thorough hash checks are done based on build_depend and fetch_depend, which makes adding symlinks to config directories unnecessary.
Added EDK2 build with just iPXE, nothing else, for images with 3MB of CBFS space.
The next section will cover post-release revisions, which were then provided as amended tarballs, re-built based off of the original one.
Minor build system cleanup.
Re-added 32-bit memtest86+ on 32-bit targets. Accidentally removed in the rev1 release.
Added missing SMMSTORE config on ThinkPad T420, T420s and T520.
Also enabled SMMSTORE config on HP Elite 8200 SFF
Documentation cleanup
Removed some missed blobs, after more thorough scan; a few microcode updates, and one VGA blob. All unused in Canoeboot, but they were present in the rev4 source archive. This new revision removed the following files:
src/mainboard/gigabyte/mz33-ar1/early_vga.bin in coreboot/default and coreboot/cros_armAnd the following blobs were removed from coreboot/fam15h_15h:
src/vendorcode/amd/agesa/f15/Proc/CPU/Family/0x15/OR/F15OrMicrocodePatch0600050D_Enc.csrc/vendorcode/amd/agesa/f15/Proc/CPU/Family/0x15/OR/F15OrMicrocodePatch0600063E_Enc.csrc/vendorcode/amd/agesa/f15/Proc/CPU/Family/0x15/OR/F15OrMicrocodePatch06000852_Enc.csrc/vendorcode/amd/agesa/f15/Proc/CPU/Family/0x15/OR/F15OrMicrocodePatch06000425.csrc/vendorcode/amd/agesa/f15/Proc/CPU/Family/0x15/OR/F15OrMicrocodePatch06000624_Enc.csrc/vendorcode/amd/agesa/f15/Proc/CPU/Family/0x10/RevD/F10MicrocodePatch010000d9.csrc/vendorcode/amd/agesa/f15/Proc/CPU/Family/0x10/RevD/F10MicrocodePatch010000c5.cNotably, the microcode blobs are in a different location in this new 15h.org tree, compared to the old 4.11 tree. Please know: these blobs were unused. Canoeboot patches coreboot so as to never add blobs, even when told to. This means that microcode updates are never applied to images, nor downloaded. In this case however, they were included directly in the tree. The coreboot upstream is much better about splitting these into their own repository, but it seems that the 15h.org fork is a bit more cavelier about keeping them in the main repository - as such, Canoeboot releases will be more vigilant from now on.
Removed one more blob: src/vendorcode/amd/cimx/rd890/HotplugFirmware.h - it was missed during the last scan. I saw it but accidentally did not include it in the nuke list. Now this blob is removed. Note that coreboot/default and cros were already checked thoroughly. The new 15h.org tree needed more handling.
The nuke function is now applied in Git, when fetching sources. It was previously only applied when preparing sources for release archives, as those are what actually get released. This new redesign brings parity with Git-based builds in line with release builds.
Coreboot 15h (15h.org fork) was heavily modified, so as to force-disable loading AMD microcode. Even when you turn on microcode, it no longer adds microcode. It would fail with a build error if you did anyway, because we remove the microcode files.
This should now be very freedom-friendly indeed. Note that I also patched 15h coreboot to always turn on CONFIG_REMOVE_MICROCODE.
General cleanup of docs, aggressively removing references to proprietary software, or projects that promote it. General cleanup to the EDK2 documentation.
Canoeboot will be submitted for evaluation by the GNU project. It is very much the intention of the Canoeboot project that Canoeboot become a part of the GNU project.
The flashing instructions, for external flashers, have removed references to flash programmers that are hard to set up with free systems; e.g. BBB/RPi. We now standardise on just the RP2040-based programmers.
Both the code and the docs should now be a ready state for the gnueval team. I don’t know whether they would accept Canoeboot, but I’ve made as many changes as I can think of within what I believe would be their own criteria, anticipating what sort of things they would have flagged regardless. The docs and the code should hopefully already be in a state such that they could accept this as-is.
Restored previous behaviour of scrubbing files at release time instead of during every download in cbmk; otherwise, you end up with a lot of junk in diffs during development, which makes working on upstreams harder. This means then that files are scrubbed during release, but not during ordinary development. The files in question are always ones that are carefully never used when building from cbmk(Git repository) anyway, so this is fine. The restored behaviour is more reliable at scrubbing tarballs, actually intended for release to the public.
No other changes were made, in rev9. This was done when it was realised that the rev6, 7 and 8 tarballs didn’t have files scrubbed in release tarballs at at all; they only get scrubbed when using the cbmk Git repository. Rather than fixing it so that it happens in both places, the old behaviour of only scrubbing release archives was restored. This is a much more conservative implementation, and reduces friction during normal development as it means that development more or less mirrors the same workflow as Canoeboot’s main upstream project.
Added patch disabling the loading of previously removed SMU firmware for AMD CIMX RD890 northbridge - also disabled (by code patching) PCIe hotplug. This fixes build errors when blobs are removing, which makes this the first revision of Canoeboot that reliably builds on these ASUS KCMA-D8/KGPE-D16 boards.
Blobs were removed from 15h.org in previous revs, but this broke the build. This patch fixes the build. NOTE: SMU firmware not used on ASUS KGPE-D16 and KCMA-D8, so this breaks nothing. PCIe hotplug basically optional - shouldn’t affect most users. Really the only thing here is CPU microcode being removed, affecting users - beware errata, e.g. VM escape bugs on 62xx/42xx opterons. 63xx and 43xx recommended when excluding microcode updates, as always.
The SMU disable patch keeps the SMU loader code in place; it still carries on like the SMU firmware was loaded, but it’s operating from the default blanked out state (blanked SMU memory). The SMU code is actually unused on ASUS KGPE-D16 and KCMA-D8 so it’s just dead code at that point. This would have to be properly split up and tidied up, upstream.
Essentially, these changes are done because there isn’t much separation in the AGESA code so a bunch of dead code gets included, even if unused. Proper splitting up of the code is needed, removing parts that aren’t used on given boards. The AGESA code is basically bolted onto coreboot, in 15h.org’s coreboot as also when it was originally in the upstream coreboot tree. The 15h.org project did add a bunch of configuration options themselves to the code, e.g. disabling AMD microcode, which Canoeboot actually doesn’t use - because Canoeboot just removes all microcode handling entirely, thus the microcode is permanently removed in Canoeboot on these machines. This is how it was always done.
Testing was done on ASUS KGPE-D16 and it boots, with this Canoeboot revision. Tested with help from the 15h.org Matrix chatroom. Thank you! ASUS KCMA-D8 is nearly identical in code, and should work just fine as well.
I also fixed some minor issues in the docs, e.g. the about page was still in the pandoc template, even though I removed it (the about page was basically just a meaningless stub that summarised what’s on the homepage).
Please note that the ASUS KGPE-D16 and KCMA-D8 still don’t have EDK2 enabled. This is because it won’t work in text mode startup on the AST2050, even if it could be used on a graphics card, and there’s no SMMSTORE driver in the 15h.org tree; lots of polishing is needed first, before EDK2 can be used on these boards, but you can easily enable it in the corresponding target.cfg file for your board and re-compile if you want to try it, adding e.g. these to the target.cfg file, e.g. config/module/coreboot/asus_kgpe_d16_4mb/target.cfg:
build_depend="coreboot/edk2_chromebook"
payload_edk2="edk2_chromebook"
YMMV but these AMD boards should be rock-solid now. 15h.org makes a lot of fixes; for example, I was told that you can use half a terabyte of RAM on these machines. That is to say, 15h.org supports more RAM than the vendor firmware officially does, on these machines.
Heavily modified all Canoeboot documentation to remove all references to projects that either are proprietary, or which openly link to or promote or otherwise facilitate the use of proprietary software. The entire Canoeboot documentation and website is now much more friendly to GNU ideology, though it already was quite friendly as it already implemented that ideology. Now it implements it even more.
Further promoted libre distros, from a curated list of just two: Parabola and Guix. These are the operating systems that Canoeboot recommends to its users, especially since Canoeboot is build-tested on Parabola; Guix could be used to create an environment to build it more robustly, in the future, though cbmk likely won’t make use of Guix itself; use of cbmk inside Guix is quite possible.
Made the binary blob extermination policy clearer, in docs.
A thorough re-scan was conducted since the last revisions, to find the last remaining binary blobs from upstream projects. Several were found, and deleted. They are:
Specifically, these blob files were removed:
in coreboot cros_arm and default trees, these files were removed:
payloads/external/iPXE/ipxe_src/src/drivers/infiniband/linda_fw.cpayloads/external/iPXE/ipxe_src/src/drivers/net/bnx2_fw.hRemoved these in u-boot/cros_arm:
drivers/usb/eth/r8152_fw.cboard/cssi/mcr3000/fpga_code.harch/powerpc/cpu/mpc8xx/micropatch_smc.cRemoved these in coreboot/fam15h_15h:
src/vendorcode/amd/agesa/f12/Proc/GNB/PCIe/Family/LN/F12PcieAlibSsdt.hCorresponding source trees were patched to fix build errors, where necessary, after removing these firmware blobs.
Blob deletion now occurs when fetching sources in cbmk.git, in addition to release archives. This brings parity with local cbmk development in line with release engineering, so that the build is identical in both cases; we previously had to be very careful that files tagged for removal in releases would not be used in local cbmk builds. The previous issue identified can be mitigated by temporarily committing deletions in hot copies of source trees, for quick patching, when testing a patch in a given project.
Canoeboot 26.10rev10 was submitted for evaluation by the GNU project, pending possible accession; Canoeboot 26.11rev11 will now be built, and this version submitted to GNU with the following notes. This was done ahead of any auditing on their part, to make sure that all blobs have been cleaned.
No blobs found in EDK2 thus far; scans are ongoing, and further amendments will be made to this release if offending files are found.
Fixed the r8152 firmware removal in U-Boot; I removed the firmware files, and the corresponding rule in the Makefile. However, I’d not removed the actual calls to the functions that updates the firmware. I had done so, but did not commit it.
It has now been committed, such that rev12 is now what rev11 should have been. Otherwise, U-Boot won’t compile without this fix in rev12.
The firmware for realtek nics is provided in U-Boot as headers, with functions in those files that are called by the driver, updating the firmware which is contained in byte arrays inside those headers. Canoeboot patches this out entirely, such that the drivers still operate but without firmware; most of the r8252 nics should still work without it, but some may be buggy.
This patched behaviour in U-Boot is identical to how deblobbed versions of Linux behave, in their driver for these NICs.
Markdown file for this page: https://canoeboot.org/news/canoeboot2611.md
This HTML page was generated by the Canoeboot Static Site Generator.
Canoeboot is discontinued. A new project was created: RBoot project, a fully free UEFI firmware distribution based on coreboot. RBoot is Canoeboot continued under a new name, with the same maintainer. The canoeboot website and release sources shall be preserved for historical purposes.