Overview
The installation starts in macOS and continues in Fedora:
- In macOS Recovery, disable Secure Boot and allow booting from external media.
- In macOS, create a separate partition for Fedora.
- Boot macOS and run the KAIT2EN installer.
- Choose a supported Fedora edition and an empty USB drive.
- The installer downloads and verifies the official Fedora image.
- It collects the Apple Wi-Fi firmware from your Mac and, where required, the PCIe Bluetooth firmware.
- It writes the unchanged Fedora image to the USB drive, then adds separate KAIT2EN boot files for keyboard, trackpad, firmware, and installer support.
- Boot the USB drive and install Fedora. After the first login, the guided KAIT2EN setup installs the remaining drivers and system integration.
- After another reboot, you can enjoy KAIT2EN on top of vanilla Fedora.
The USB drive is a live installer. It only carries the drivers needed to install KAIT2EN.
The installer supports Fedora Workstation, Fedora KDE Desktop and Fedora COSMIC Spin. We recommend Workstation (GNOME), which the KAIT2EN developers use and test. Feedback on the other desktops is welcome.
Before you start
You need:
- a T2 Mac with macOS still installed
- an empty USB drive
- an internet connection in macOS
Back up important data before changing partitions or boot settings.
Keep macOS installed. It is the clean source for Apple firmware and can recover T2/bridgeOS hardware states.
Disable Apple Secure Boot#
- Shut down the Mac.
- Turn it on and immediately hold
Command-Runtil macOS Recovery starts. - Select a macOS administrator account and enter its password when prompted.
- From the menu bar, open
Utilities>Startup Security Utility. - Select the macOS system disk if the utility asks for one.
- Set the following options:
Secure Boot: No Security
Allowed Boot Media: Allow booting from external or removable media
- Close Startup Security Utility and restart into macOS.
Apple Secure Boot cannot boot standard Fedora while it is enabled. The installer checks the current setting and warns when it cannot confirm that Secure Boot is disabled.
Create space for Fedora#
Open Disk Utility in macOS. Select the internal macOS disk or container, choose
Partition, and add an exFAT partition for Fedora, not an APFS volume.
Fedora reformats it during installation. exFAT only makes it easy to
identify.
Choose the size carefully because resizing the partitions later is not a small
maintenance task. Keep at least 50 GB for macOS so there is enough space for
updates, firmware work, and recovery tasks. Give the remaining space you want
to use for Linux to the new partition.
Do not delete the EFI partition or macOS.
Create the Fedora USB drive
Boot macOS and connect the empty USB drive. Open Terminal and run:
curl -fsSL https://github.com/kaiT2en/KaiT2en-Fedora/releases/latest/download/install-kait2en-fedora.sh | bash
Choose the Fedora desktop and USB drive. The script downloads and verifies the official Fedora image, finds the Apple Wi-Fi firmware used by this Mac and asks for an exact confirmation before erasing the USB drive.
The KAIT2EN boot files go to the USB drive's EFI partition. Initramfs overlays add the input drivers and installer integration at boot.
Be exact when selecting the drive. All data on it will be destroyed.
Install Fedora
Shut down or reboot the Mac. Hold Option during startup and select the orange
EFI Boot entry for the Fedora USB drive. The KAIT2EN Fedora entry starts
automatically.
Keyboard, trackpad, and Wi-Fi should work in the live system and installer. The live system installs the Apple Wi-Fi firmware from the USB drive for itself, so you can connect to a network before or instead of installing Fedora.
Macs whose Bluetooth controller sits on PCIe (BCM4377) also get their Apple Bluetooth firmware in the live system, so a Bluetooth keyboard or mouse can be paired before installing. Every other T2 Mac drives Bluetooth over UART and needs no separate firmware file.
Install Fedora normally. Use custom partitioning and select the Linux partition
you created in macOS. Do not erase the whole disk or macOS. When reinstalling,
format an existing Linux /boot partition so old kernels do not fill it.
After installation finishes, remove the USB drive and boot the installed Fedora system.
If the live system does not start#
The boot menu offers a few troubleshooting entries that are only needed when the normal boot does not work. Try them in this order and stop at the first one that works:
Troubleshooting: KaiT2en with boot messagesshows the console instead of the logo. Photograph the last lines for a bug report.Troubleshooting: KaiT2en with the dedicated GPU disabledkeepsamdgpuout of the boot and leaves the Intel GPU fully accelerated.Troubleshooting: KaiT2en with basic graphicsaddsnomodeset. Rendering is done in software and feels slow, but it can run the installation.Troubleshooting: KaiT2en with basic graphics and conservative PCIeis the last resort and also covers a power off coming from PCIe or Thunderbolt.
All of them keep the KAIT2EN input drivers. If entry 2 or 3 was needed, make the fix permanent afterwards as described in Configure GPUs.
If hardware is missing in the live system#
KAIT2EN supports the known T2 configurations, but Apple shipped several controller and firmware variants. If keyboard, trackpad, Wi-Fi, or PCIe Bluetooth support is missing, collect diagnostics before continuing with the installation.
The individual helpers can be run manually to see the Wi-Fi or Bluetooth setup result directly:
sudo /run/kait2en/kait2en-live-wifi
sudo /run/kait2en/kait2en-live-bluetooth
For a complete diagnostic archive, run:
sudo /run/kait2en/kait2en-live-diagnostics --rerun
This reruns the firmware setup while recording what happened. The archive lands
on a second USB drive when one is mounted, otherwise in /tmp. The path is
printed at the end. It contains host names, MAC addresses, and the names of
nearby wireless networks, so inspect it before attaching it to a bug report.
Finish the KAIT2EN installation
Sign in to Fedora and connect to Wi-Fi. A terminal opens automatically and starts the KAIT2EN installer in two phases. Do not close this window and follow the prompts.
The first phase updates Fedora and prepares the new kernel. Reboot when asked. After signing in again, the second phase opens automatically and runs the regular KAIT2EN installer. Reboot once more after it completes successfully.
If the terminal does not appear, open one and run this command without sudo:
kait2en-install
The installer asks for administrator access when it is needed. It can also be started again at any later time to update KAIT2EN.
KAIT2EN applications
KAIT2EN includes several applications for monitoring and configuring T2 Mac hardware. The installer selects hardware-specific applications where necessary. Graphical apps show up in the app drawer after installation. T2 Journal is used from a terminal. Their names start with "T2", which makes them easy to find. The updater is called KaiT2en Update.
KaiT2en Update

Experimental. kait2en-install stays the recommended way to update, see
Updating.
Compares your installation with GitHub and installs only what changed. A full run of the installer builds every app, every module and the initramfs again. Most updates only touch one or two of them.
- Shows the local checkout, the state on GitHub and the new commits.
- Lists the installer steps and apps whose sources changed, each with a switch and the files that caused it. Unselected steps are offered again on the next check.
- Shows a restart hint when kernel modules or the initramfs were updated.
- Offers to install everything when the installer itself changed.
- Adds or removes the optional parts, T2 Touch Bar, Automatic brightness and KaiT2en Vornehm. A switch only marks the change, Update carries it out.
Each step records the commit it was installed from in
/var/lib/kait2en-installer/applied/. Installations from before the app have
no records, so the first check compares with the local checkout. Changes to
the website or the docs install nothing.
The installation runs through a restricted helper that asks for your password and only accepts the names of known installer steps and apps.
T2 Fan Control

Shows temperatures and fan speeds and drives both fans along an editable
curve. The service t2-fancontrol.service keeps fan control active across
login, suspend, resume and reboot. The app talks to it over a Unix socket.
Native SMC or custom curve#
The switch in the header bar selects who drives the fans.
- On: the curve below controls both fans.
- Off: the SMC controls the fans, as under macOS. The app keeps showing temperatures and fan speeds.
Curve#
The curve follows the hotter of CPU and GPU. CPU is the mean of the SMC
sensors TC0E and TC0F, GPU the highest GPU reading. Under Advanced
settings a third sensor can be added. The curve then follows the highest of
the three.
Drag the start and end points to set the speed at low and high temperature.
The hollow ring bends the curve. Above the rightmost point both fans run at
100 %. Fan percentages are relative to each fan's minimum and maximum RPM, so
0% is the hardware minimum speed.
System temperature wall#
The red vertical line is the system temperature target, 45 °C by default. The system temperature is the mean of all positive SMC readings except the CPU core, die and package sensors. It reflects the heat held in the logic board, heatpipe and case.
- 2 °C above the target, both fans go to 100 %.
- They return to the curve once the system temperature has stayed 2 °C below the target for 20 seconds and the Overrun time (default 5 s) has passed.
This keeps the case from heating up until the SMC throttles the CPU through PROCHOT.
Advanced settings also offers an any-sensor limit: both fans go to 100 % when any sensor reaches the threshold, with a 5 °C release hysteresis. It is off by default.
Settings#
The configuration is /etc/t2-fancontrol/config.txt. The default curve is
0:10,70:25,95:65 in temperature:percent pairs.
T2 SMC Control

Displays SMC temperatures, fan speeds, power data, and the hardware clock, and can write the current system time to that clock. The values are read directly from the SMC. GNOME and Plasma show their own battery estimates.
The battery charge limit is shown here and set in the desktop's power
settings. t2smc exposes it as the standard charge_control_end_threshold.
With a charge limit set, the background service t2-smc-gaugingd lifts it for
a full charge from time to time, like macOS does. A battery that never charges
to full keeps its gauge from recalibrating, and the reported charge can then
collapse under load.
T2 Zone Power

Applies the power limits of the SMC the way macOS does. The SMC shares the cooling budget between CPU, integrated GPU and discrete GPU by itself and asks the operating system to lower each of them in steps. Linux used to ignore these requests, so the SMC kept escalating until it throttled the CPU hard through prochot.
A background service follows the SMC steps without any settings. It caps the CPU clock, the integrated GPU clock and the power of the discrete GPU, and uses forced idle when the SMC asks for it. On a combined CPU and GPU load the SMC then settles on steady clocks instead of dropping to 800 MHz.
The app itself only shows what happens: zone power against its target, zone throttling, the applied limits and the CPU, GPU and heatpipe temperatures. T2 Zone Power replaces T2 CPU Control, which the installer removes.
T2 Power Explorer

Shows the kernel device tree with the runtime power state of every device, grouped into PCI, platform and virtual devices. It helps find devices that keep the system out of deeper package C-states.
Each device has an assessment:
- runtime PM failed: the driver reported a runtime PM error.
- active leaf device under automatic runtime PM: the device may suspend but stays active. This is the usual candidate for a blocked C-state.
- runtime PM disabled by policy:
power/controlison. It can be enabled in T2 Power Tune. - runtime PM disabled on a parent or supplier: the same on a device with children, which keeps them active too.
A parent marked "A descendant contains a power-management issue" has a child with one of these findings. Selecting a device shows its driver, runtime PM counters, PCI power states, wake support, link speed and width and device links.
T2 Journal
Fetches Apple T2 bridgeOS logs over the internal T2 network
link and merges them chronologically with the Linux journal. It can select one
boot or all retained boots, filter by regular expression or source, and emit
text or JSONL. The first query downloads a BridgeOS snapshot automatically. Use
t2journal refresh to replace it explicitly.
The link is set up by the installer and managed by kait2en-t2-remote, the
same service that holds the T2 video encoder open. It is disconnected before
suspend and reconnected after resume, so there is nothing to configure.
Typical queries are:
t2journal -b
t2journal -b -1 --grep 'suspend|watchdog'
t2journal --allboots --source t2
t2journal -b --output jsonl > merged.jsonl
t2journal refresh --sysdiagnose additionally keeps a copy of the downloaded
sysdiagnose archive in the current directory, e.g. to extract panic logs from
it yourself.
Run t2journal --help for all filtering and refresh options.
T2 Debug

Shows live data from bridgeOS, the T2's own operating system. It connects over the internal T2 network link, the same one T2 Journal uses, to the T2's Instruments diagnostic service. It only reads.
Two tabs:
- deviceinfo is a "top" for the T2: every bridgeOS process with its CPU, power score, interrupt wakeups, memory footprint and disk writes, updated once a second. Click a column header to sort. Buttons run one-shot queries (mach time, network info, the kdebug trace-code table, the full service capability list) and list a bridgeOS directory.
- live log streams the T2's
os_login real time, decoded to readable lines and coloured by level likedmesg. A regex box filters, a "hide HID" toggle drops the input-device chatter, and the subsystem list on the right lets you tick exactly which subsystems to show.
This is the tool for watching what the T2 does in the moment, for example the
SMC and power events around a GPU switch or a suspend. Logs the T2 marks as
private appear as <private>. bridgeOS redacts them before they reach Linux.
The command t2debug gives the same data without a GUI, for example over SSH (t2debug procs, t2debug logs --no-hid,
t2debug sysmon). Run t2debug --help for all subcommands.
T2 Power Tune

Lists PCIe ASPM link states, LTR requirements, runtime power management, wake sources and other power tunables, and shows the package C-state residency of the last second. It replaces powertop and TLP for reaching deeper package C-states.
- Apply selected changes writes the selection for the current boot and verifies it. Changing a checkbox writes nothing.
- Create systemd service stores the selection in
kait2en-power-tune.service, which applies it at every boot. - Rescan reads the hardware state again.
Change one item at a time, check the C-state residency and test suspend and resume before making it persistent. More enabled options do not mean more savings. Typical failures are missing Wi-Fi or Bluetooth after suspend, PCIe errors, audio dropouts and I/O timeouts. Leave BCM4377 runtime PM off unless suspend and resume were tested. The help button of each section explains its risks.
Reset#
sudo systemctl disable --now kait2en-power-tune.service
sudo rm /etc/systemd/system/kait2en-power-tune.service
sudo systemctl daemon-reload
--now restores the values saved before the service applied its changes.
If the system no longer boots, add the kernel argument
systemd.mask=kait2en-power-tune.service once in GRUB and run the commands
above.
T2 Force Click

Sets the pressure for a normal click and for Force Click, the harder press after it. Tap-to-click, scrolling and gestures stay with libinput.
- Click force: Light, Medium or Firm.
- Force click force: relative to the click force.
- Disable Force Click keeps the normal click only.
On Force Click binds one action:
- Copy / Paste: the first Force Click sends Ctrl+C, the next Ctrl+V, and so on.
- Custom key combo: a combination set with Record shortcut…, sent through a virtual keyboard. Works under Wayland and X11.
- Run command: a shell command, run as the logged-in user.
Force Click is also the key event BTN_TASK on the trackpad's input device,
so desktop shortcuts and other tools can bind it directly. A physical
three-finger click is a middle click.
The service t2-force-click.service applies the settings at boot and runs the
action. Settings are in /etc/t2-force-click/config.txt.
T2 Keyboard Backlight
Installed on every T2 MacBook, with or without a Touch Bar.
Turns the keyboard backlight off after 30 seconds without input and back on with the next key press, trackpad touch or Touch Bar touch.
The setting lives in /etc/kait2en/kbd-backlight.toml:
enabled = true
idle_timeout_ms = 30000
idle_timeout_ms accepts 5,000 to 3,600,000 ms. enabled = false leaves the
backlight alone. Apply changes with:
sudo systemctl restart t2-kbd-backlight
Updates never overwrite this file.
T2 Touch Bar
Optional. The installer only asks on models with a Touch Bar. Without it, Apple's native Touch Bar keeps working.
Keeps the Touch Bar dark until it is touched or Fn is pressed.
- Offers a media row, an F-key row and a row with print, insert, delete, home, end and page keys.
- Two-finger swipes change the volume on the dark bar.
- Two-finger swipes change the row on a lit bar.
- Three-finger swipes change the display brightness on a dark bar.
- Touch ID shows an "Unlock with Touch ID" prompt.
- Tracks from media players briefly appear on the dark bar. A touch on the title pauses.
- While something plays, a faint play triangle sits in the middle of the dark bar. A tap brings the track back, holding it pauses.
- After a pause from the bar, a tap on the pause bars plays on. They show along with the escape key.
- Remembers the last active row.
- Holding Fn switches between the media row and the last remembered row.
- Up to four personal keys can be configured in
~/.config/kait2en-touchbar/keys.toml.
Reboot once after the first install.
Settings are in /etc/kait2en/touchbar.toml. To return to the native Touch
Bar, run sudo systemctl --global disable kait2en-touchbar.service and
reboot, or remove it with
sudo /usr/local/src/KaiT2en-Fedora/apps/t2-touchbar/uninstall.sh.
T2 Hybrid GPU Control

Used on the MacBookPro15,1, MacBookPro16,1 and MacBookPro16,4. It enables an iGPU-driven desktop with PRIME offload to the AMD GPU, which wakes on demand and returns to D3cold when idle. Suspend and resume work in this mode. A discrete-GPU boot mode remains available as a recovery option. To switch it on, see Configuring GPUs.
macOS sets the boot GPU back to the discrete GPU every time it starts. The app therefore installs a small UEFI program, t2-gpu-preboot, that runs before Linux. When hybrid graphics is enabled and the boot GPU has been changed, it restores the integrated GPU, shows a short notice and restarts once. Otherwise it starts Linux without delay. If the restart does not take effect, it shows a warning and Linux starts on the discrete GPU until hybrid graphics is applied again in the app.
T2 GPU Control

For MacBook Pro models with Intel and AMD graphics other than the MacBookPro15,1, 16,1 and 16,4, which use T2 Hybrid GPU Control.
- Primary GPU: Integrated or Discrete for the next boot.
- Power off discrete GPU: after an integrated boot, the dGPU is powered off to save idle power. It stays unavailable until the next reboot.
- AMDGPU power-saving profile: applies the driver power-saving profile after boot and resume while the dGPU stays on.
GPU status shows the active GPU, the configured boot GPU and the dGPU state. Apply Changes stores the selection and asks for your password. Reboot activates it. To go back, select Discrete and apply again.
The integrated GPU as primary lowers power use and makes suspend more reliable. See Configuring GPUs.
T2 TrueTone

T2 TrueTone keeps the white of the display paper white in any light, warms it in the evening and sets the display brightness from the ambient light. T2 TrueTone uses the ambient light sensor of the T2 and is installed with GNOME on the T2 MacBooks, the iMac20,1 and the iMac Pro.
After the first installation it is off. Open T2 TrueTone and press Start
next to Service. This starts the user service t2-truetone.service, which
also runs after the next login. Stop turns it off again.
While it runs, GNOME Night Light, GNOME's automatic brightness and the dimming of the screen when idle are turned off, the app says so at the top. Each comes back when its feature is switched off in the app.
True Tone#
The sensor measures the color of the ambient light. The display white follows it, warmer under lamps, cooler in daylight.
- Strength sets how far the display follows the light. The default is marked on the slider. Lower values keep the display closer to neutral white.
- Transition sets how long the display takes to settle after the light changes.
- In dim light the white settles on a fixed warm white.
Evening mode#
Warms the display white between From and Until every day. Color temperature sets the white at full evening mode, Fade the minutes it takes to fade in at the start and out at the end. Evening mode and True Tone work together.
Auto brightness#
Adjusts the display brightness to the ambient light the way macOS does.
- Changes fade in slowly over a few seconds, in steps too small to see.
- Changes in light of less than about 20 % are ignored, so the screen does not follow every shadow.
- Setting the brightness by hand pauses it. One second later it learns the new brightness for the current light and keeps following from there.
- The slider and the brightness keys always start from the real brightness. The GNOME Shell extension KaiT2en Auto Brightness keeps the slider in sync and is switched on with auto brightness.
The learned curve is in ~/.local/state/t2-truetone/brightness/curve.
Deleting it while the service is stopped starts again from the factory curve
of the model.
T2 TrueTone replaces the former automatic brightness service. The update takes over its learned curve and keeps auto brightness on for the user who runs it.
T2 Kernel Builder

Builds Fedora kernels with the T2 configuration and your own patches.
- Base configuration: choose Use Fedora default configuration or Run localmodconfig. localmodconfig keeps only the modules loaded right now, so hardware that is unplugged during the build can lose its driver.
- Optional components: the kernel's Kconfig tree. The T2 requirements are locked, other options can be changed.
- Choose the patch folder with Choose folder. Patches are applied in alphabetical order, at least one is required.
- Build kernel downloads the Fedora kernel source RPM and builds without root. By default all CPU threads but one are used.
- Install built kernel installs the finished build and asks for your password. The kernel then appears in GRUB.
The Cleanup tab removes installed custom kernels and cached sources. The running kernel and rescue images are protected.
Sources and build trees are kept in ~/.cache/t2-kernel-builder/build.
Builds that finished before the app was closed are offered again under the
completed builds.
Audio DSP
KAIT2EN installs the audio DSP automatically, with the profiles for all supported models. Other models keep the native T2 audio devices.
DSP in general#
The T2 audio driver exposes the physical speaker channels. The model-specific processing runs on the host, under macOS as well. KAIT2EN provides that processing as a PipeWire filter graph per model.
Depending on the model, the graph
- distributes stereo audio across the physical woofer and tweeter channels
- applies the model's equalization and crossovers as biquad filters
- applies a multiband compressor and limiters
- widens the stereo image with crosstalk cancellation
- adds virtual-bass processing
On supported Macs, the resulting output appears as DSP Speakers device. The unprocessed Apple Internal Speakers device remains available for comparison and diagnostics. Headphones do not pass through the speaker DSP graph.
Supported models#
| Model | DSP profile |
|---|---|
| MacBook Air 2018 | MacBookAir8,1 |
| MacBook Air 2019 | MacBookAir8,2 |
| MacBook Air 2020 (Intel) | MacBookAir9,1 |
| MacBook Pro 15-inch 2018/2019 | MacBookPro15,1 |
| MacBook Pro 13-inch 2018/2019, four Thunderbolt ports | MacBookPro15,2 |
| MacBook Pro 15-inch 2018/2019, Radeon Pro Vega | MacBookPro15,3 |
| MacBook Pro 13-inch 2019, two Thunderbolt ports | MacBookPro15,4 |
| MacBook Pro 16-inch 2019 | MacBookPro16,1 |
| MacBook Pro 13-inch 2020, four Thunderbolt ports | MacBookPro16,2 |
| MacBook Pro 13-inch 2020, two Thunderbolt ports | MacBookPro16,3 |
| MacBook Pro 16-inch 2019 | MacBookPro16,4 |
| iMac 27-inch 2020 | iMac20,1 |
| iMac Pro 2017 | iMacPro1,1 |
The installation reads the model from DMI and writes the matching graph to
/etc/pipewire/pipewire.conf.d/51-t2-dsp.conf. At boot udev assigns a short
ALSA card ID, for example t2-15_1, and WirePlumber matches that ID and the
UCM Speaker/Mic nodes. Reboot after installing or removing t2-dsp.
Automatic selection#
The DSP sink has session priority 1400, above the raw speaker sink, and the
headphone sink 1500. While a T2 output is the default, the WirePlumber script
t2-default-output.lua selects the headphones when they are plugged in and the
DSP speakers otherwise. A USB, HDMI or Bluetooth output chosen by the user stays
selected.
Profile origins and support#
The graphs are generated per model by KAIT2EN. License information is in
/usr/share/licenses/t2-dsp/. Thanks to
lemmyg, whose PipeWire DSP
graphs for T2 Macs were the starting point. Report problems to the
KAIT2EN issue tracker.
Check the active output#
The sound settings should show the model-specific DSP output on a supported Mac. PipeWire can also list it directly:
wpctl status
The active sink is marked with an asterisk. If the DSP device is missing after the regular installation and a reboot, include the model identifier and this output in a KAIT2EN issue:
cat /sys/class/dmi/id/product_name
wpctl status
journalctl --user -b -u wireplumber -u pipewire -u pipewire-pulse
Butterfly keyboard debounce
Butterfly keyboards sometimes register one keystroke twice, so a word like
"unwanted" comes out as "unwaanteed". t2hid can filter these repeats. It drops
a key press that follows the release of the same key within a configurable
number of milliseconds, together with the matching release.
The filter only applies to butterfly keyboards:
| Model | Identifier |
|---|---|
| MacBook Pro 13" 2018/2019, four Thunderbolt ports | MacBookPro15,2 |
| MacBook Pro 13" 2019, two Thunderbolt ports | MacBookPro15,4 |
| MacBook Pro 15" 2018/2019 | MacBookPro15,1 and MacBookPro15,3 |
| MacBook Air 2018/2019 | MacBookAir8,1 and MacBookAir8,2 |
It is off by default.
Enable it#
Try it at runtime first:
echo 40 | sudo tee /sys/module/t2hid/parameters/debounce_ms
0 turns it off again. To keep it across reboots, add the kernel argument:
sudo grubby --update-kernel=ALL --args="t2hid.debounce_ms=40"
Tune the interval#
40 ms is a good start. Raise the value if keys still repeat, lower it if
quickly typed double letters such as "ee" lose a letter. Every dropped press is
logged with its interval once dynamic debug is enabled for t2hid:
echo 'module t2hid +p' | sudo tee /sys/kernel/debug/dynamic_debug/control
sudo dmesg -w | grep debounce
A key that bounces when pressed and is then held down produces one character and no key repeat.
Configuring modifier key positions
The position of some modifier keys on Apple keyboards, such as the Control key, might be impractical for some users,
and alternative positions might make keyboard shortcuts more familiar.
t2hid exposes options to swap some specific keys.
Swapping Control and Command keys#
This will switch the Control and the Command keys. All Command keys will act as Control keys and vice versa.
To enable this, add the kernel argument:
sudo grubby --update-kernel=ALL --args="t2hid.swap_ctrl_cmd=1"
Reboot for the change to take effect.
Replacing 1 with 0 in the above command turns it off again.
Swapping Control and Fn keys#
This will switch the Fn and left Control keys.
To enable this, add the kernel argument:
sudo grubby --update-kernel=ALL --args="t2hid.swap_fn_leftctrl=1"
Reboot for the change to take effect.
Replacing 1 with 0 in the above command turns it off again.
Swapping Option and Command keys#
This will switch the Option and the Command keys. All Command keys will act as Option keys and vice versa.
To enable this, add the kernel argument:
sudo grubby --update-kernel=ALL --args="t2hid.swap_opt_cmd=1"
Reboot for the change to take effect.
Replacing 1 with 0 in the above command turns it off again, while 2 swaps only the left Option and left Command keys.
Swapping keys at the desktop level#
For GNOME users, it's possible to perform more flexible remapping using GNOME Tweaks, but this will apply to all keyboards, not just Apple ones.
This is an alternative to the t2hid configuration above, and will result in swapping the keys back if the same configuration is applied in both GNOME Tweaks and in t2hid.
Install GNOME Tweaks (either from the Software app or with sudo dnf install gnome-tweaks) and open it.
From the sidebar, navigate to Keyboard, then click on Additional Layout Options. In this window, particularly inside the "Ctrl position" section, you can check multiple options as you see fit.
Keep in mind that, in this context, "Win" refers to Command keys and "Alt" refers to Option keys.
Configuring GPUs
If a Mac has a dGPU, it boots from it and uses it as the primary display adapter by default. Which GPU options KAIT2EN offers depends on the model:
- MacBookPro15,1, MacBookPro16,1 and MacBookPro16,4 support hybrid graphics through T2 Hybrid GPU Control.
- Other MacBook Pro models with a dGPU can switch between iGPU and dGPU through T2 GPU Control.
- iMacs cannot switch, because there are no display lines from the iGPU to the panel. The iGPU is only used for offloading, and KAIT2EN installs no GPU app. The 5K iMacs (iMac20,1 and iMac20,2) still get a patched AMDGPU module, which carries their 5K panel support.
- Mac Pros have no iGPU, so there is nothing to configure.
Hybrid graphics on MacBookPro15,1, 16,1 and 16,4#
KAIT2EN installs T2 Hybrid GPU Control on these models. Open it from the application menu and enable Hybrid graphics, then reboot.
Hybrid graphics makes the integrated GPU the display GPU. Applications can still use the AMD GPU through PRIME offload. The kernel wakes it automatically for accelerated work and returns it to D3cold when it becomes idle. This keeps the dGPU available without paying its idle power cost. System suspend and resume are fully supported in hybrid mode on all three models.
Hybrid graphics needs the patched AMDGPU module described below. The app reports whether its runtime-PM support is active.
The discrete-GPU boot option remains available as a recovery setting. Rebooting is always a separate action so changing the stored boot GPU does not restart the system unexpectedly.
The patched AMDGPU module and kernel updates#
On the three MacBook Pro models above and on the 5K iMacs, the installer builds a patched AMDGPU module for the current Fedora kernel. It carries hybrid runtime PM for the MacBook Pros and the 5K panel support for the iMacs.
This module is not managed by DKMS, but the installer adds a kernel-install
hook that rebuilds it for every kernel Fedora installs later. The build runs
during the kernel update, after DKMS and before the initramfs is generated, so
the new kernel boots with the patched module. It downloads the kernel's source
RPM, so it needs network access and adds a few minutes to the update. dnf does
not show its output. It is written to /var/log/kait2en-gpu-runtime-pm.log.
If the build fails, for example without network access, the update itself still completes and the new kernel boots with Fedora's stock AMDGPU, without hybrid runtime PM or 5K support. Rebuild it for that kernel and reboot:
sudo /usr/local/libexec/kait2en/gpu-runtime-pm/install-gpu-runtime-pm.sh install <kernel>
sudo reboot
Other MacBook Pro models with a dGPU#
Other Intel/AMD MacBook Pro models use T2 GPU Control. Hybrid runtime PM is not enabled on those models because their dGPU power-on path is not yet reliable. T2 GPU Control has options to switch between iGPU and dGPU and to enable power saving for the dGPU. For the changes to take effect you need to reboot. Usually, users prefer iGPU as primary to save some energy and make suspend more reliable.
Hardware video decoding
Fedora's GPU drivers do not expose hardware decoding for codecs such as H.264 and H.265. This affects both AMD GPUs and Intel iGPUs. Browsers and media players can therefore fall back to CPU decoding even though the GPU contains a supported video decoder.
T2 Macs do not provide AV1 hardware decoding. YouTube should use H.264 or a hardware-supported VP9 profile to avoid unnecessary CPU load.
This page is about decoding on the GPUs. HEVC encoding runs on the T2 itself, see Hardware video encoding.
Install the VA-API drivers#
Run the installer from the KAIT2EN repository:
cd /usr/local/src/KaiT2en-Fedora
sudo bash ./scripts/fedora/install-hardware-video-decoding.sh
The script enables RPM Fusion, installs the appropriate VA-API drivers for every
detected Intel and AMD GPU, and checks each render node. Review the final output:
H.264, HEVC and VP9 decoding and encoding are reported as available or
not supported by this GPU for each GPU. Only missing H.264 decoding is a
warning, since every T2 Mac GPU supports it. The other gaps are hardware limits,
for example the Coffee Lake iGPU has no VP9 encoder and the Polaris dGPUs
have no VP9 decoder.
No general system upgrade is performed. Browser configuration is still required as described below.
Brave and YouTube#
Open Brave's system settings and enable Use graphics acceleration when available, then restart Brave.
YouTube normally chooses between H.264, VP9 and AV1 based on the capabilities reported by the browser. T2 Macs cannot decode AV1 in hardware. To force YouTube to request H.264 in Brave, install h264ify from the Chrome Web Store. This does not interfere with Brave Shields or its ad blocking.
H.264 streams on YouTube are commonly limited to 1080p. Disable the extension when a higher resolution is more important than lower CPU use.
Start a YouTube video, right-click it and open Stats for nerds. The codec field identifies the selected stream:
avc1is H.264.vp09is VP9.av01is AV1.
For the forced H.264 configuration, the field must start with avc1.
Open brave://gpu and check that Video Decode reports hardware
acceleration. For the active playback session, brave://media-internals
provides the more useful per-stream decoder details.
Firefox and YouTube#
In Firefox settings, leave hardware acceleration enabled. Open about:config,
set the following preference to false, and restart Firefox:
media.av1.enabled
This disables AV1 but still allows YouTube to select VP9. To force H.264, install enhanced-h264ify from Mozilla Add-ons and block VP9 and AV1 while leaving H.264 enabled.
Use YouTube's Stats for nerds as described above. Firefox also reports its
decoder support under about:support in the codec and media sections.
Test outside the browser#
MPV can confirm that VA-API works independently of browser configuration:
mpv --no-config \
--hwdec=vaapi-copy \
--hwdec-codecs=all \
--vaapi-device=/dev/dri/renderD128 \
--term-playing-msg='Hardware decoder: ${hwdec-current}' \
/path/to/video.mp4
Replace the render node and video path as required. A hardware-decoded stream
reports vaapi-copy instead of no.
Hardware video encoding
The T2 contains Apple's video encoder, the AVE. KAIT2EN exposes it to Linux twice, as two standard V4L2 memory-to-memory encoders, so ffmpeg, HandBrake and anything else that speaks V4L2 can hand it raw frames and receive compressed video. The Intel and AMD GPUs keep doing the decoding. The T2 only encodes.
| Device name | Path on the T2 | Output | Made for |
|---|---|---|---|
apple-ave-enc |
AVE bridge, like macOS VideoToolbox | HEVC, 8 and 10 bit | Transcoding files |
t2-sidecar |
The low-latency encoder macOS uses for Sidecar | H.264 and HEVC, 8 bit | Streaming the desktop, see Sidecar |
v4l2-ctl --list-devices shows which /dev/video node each one got.
AVE encoder#
- HEVC (H.265) only. There is no H.264 output.
- Main profile from 8-bit
NV12input, Main 10 fromP010input. - Frame sizes from 128x128 up to 4096x2304.
- One encode at a time. A second session is refused with
EBUSYuntil the first has finished.
ffmpeg#
Fedora's ffmpeg-free already ships the V4L2 encoder wrapper. The encoder
expects NV12 frames, so tell ffmpeg to convert:
ffmpeg -i input.mp4 -pix_fmt nv12 -c:v hevc_v4l2m2m -b:v 8M -c:a copy output.mp4
-b:v sets the target bitrate and -g the keyframe interval. -profile:v
and -level are passed through as well. Without -pix_fmt nv12 ffmpeg stops
with Encoder requires nv12 pixel format.
Fedora's ffmpeg does not know P010 on V4L2 devices, so 10-bit output is
not available from the command line. Use the HandBrake build for Main 10.
HandBrake with T2 AVE support#
The t2-ave branch of our HandBrake fork
adds the encoder as H.265 (Apple T2 AVE) and teaches its bundled ffmpeg
the 10-bit input format. Choose the main10 profile for 10-bit output.
Install our HandBrake fork with
sudo dnf install git gcc gcc-c++ make autoconf automake libtool pkgconf-pkg-config meson ninja-build nasm cmake cargo cargo-c patch tar python3 bzip2-devel xz-devel zlib-devel numactl-devel gtk4-devel glib2-devel libxml2-devel lame-devel opus-devel speex-devel libvpx-devel libass-devel libogg-devel libvorbis-devel libtheora-devel x264-devel jansson-devel libjpeg-turbo-devel gettext-devel desktop-file-utils
git clone --branch t2-ave https://github.com/deqrocks/HandBrake.git
cd HandBrake && ./configure --launch-jobs="$(nproc)" --launch
sudo make -C build install
Sidecar encoder#
The T2 offers this encoder to macOS for Sidecar. It only exists while the
kait2en-t2-remote service holds its connection to the T2. The T2 then shows
the virtual USB device "SideCar AVE" (05ac:9312) and the t2-sidecar
module turns it into the t2-sidecar encoder.
- H.264 (High profile) and HEVC (Main profile) from 8-bit
NV12input. - About 85 frames per second at 1920x1080 and 50 at 2560x1600.
- About 20 ms from handing over a frame to receiving it encoded.
- Double buffered, with scatter-gather DMA.
ffmpeg -i input.mp4 -pix_fmt nv12 -c:v h264_v4l2m2m -b:v 10M -c:a copy output.mp4
ffmpeg uses the first /dev/video node that can encode the requested format.
H.264 always lands on t2-sidecar because the AVE encoder has no H.264. With
hevc_v4l2m2m ffmpeg can pick either encoder, so Sidecar streaming uses H.264.
H.264 also has lower latency at a higher bitrate.
Streaming using Sidecar
With the T2's Sidecar encoder, the desktop can be streamed to an Android tablet, iPad, a phone or another computer. Sunshine runs on the Mac and encodes with the T2, and Moonlight shows the stream on the other device and sends touch, mouse and keyboard input back. The T2 encodes 1920x1080 at about 85 frames per second with about 20 ms latency and leaves the CPU free.
The encoder is described in Hardware video encoding.
Sunshine with V4L2 support#
V4L2 encoder support for Sunshine is in
pull request #5717, still
under review. The t2-sidecar branch of
our Sunshine fork carries it unchanged
until it is merged. The GPU converts every captured frame directly into the
encoder's input buffers.
Install our Sunshine fork with
sudo dnf install git cmake ninja-build gcc gcc-c++ glslc npm python3-jinja2 desktop-file-utils libappstream-glib appstream boost-devel boost-static libcap-devel libcurl-devel libdrm-devel libevdev-devel libva-devel libX11-devel libxcb-devel libXcursor-devel libXfixes-devel libXi-devel libXinerama-devel libXrandr-devel libXtst-devel mesa-libGL-devel mesa-libgbm-devel miniupnpc-devel numactl-devel openssl-devel opus-devel pipewire-devel pulseaudio-libs-devel qt6-qtbase-devel qt6-qtsvg-devel vulkan-loader-devel
git clone --branch t2-sidecar --recurse-submodules --shallow-submodules https://github.com/deqrocks/Sunshine.git
cd Sunshine
cmake -B build -G Ninja -DCMAKE_BUILD_TYPE=Release -DBUILD_DOCS=OFF -DBUILD_TESTS=OFF -DSUNSHINE_ENABLE_CUDA=OFF -DSUNSHINE_ASSETS_DIR=share/sunshine
ninja -C build
sudo cmake --install build
Configuration#
Put this into ~/.config/sunshine/sunshine.conf:
encoder = v4l2m2m
capture = portal
hevc_mode = 1
av1_mode = 1
system_tray = disabled
encoder = v4l2m2mselects the V4L2 encoder.hevc_mode = 1andav1_mode = 1keep the stream on H.264. With HEVC, ffmpeg may pick the AVE encoder instead oft2-sidecar.capture = portalrecords the screen through GNOME's screen sharing.system_tray = disabledis needed on GNOME. Without a tray, Sunshine otherwise ends right after starting.
Start sunshine from a terminal. On the first start GNOME asks which screen
to share. Pick the built-in display. Sunshine remembers the choice and restarts
itself. Then open https://localhost:47990, create a user name and password,
and pair Moonlight with the PIN it shows.
Extended display#
To use the tablet as a second screen, switch on the Sidecar display:
t2-sidecar on
GNOME then shows an additional monitor next to the built-in display. Arrange it,
set its resolution or switch to mirroring in Settings > Displays like any other
monitor. Pick the same resolution as in Moonlight, otherwise Sunshine scales
every frame and the picture gets less sharp. The next t2-sidecar on starts
with the resolution picked last.
With Sunshine installed to /usr/local/bin/sunshine as described above,
t2-sidecar on also starts Sunshine, and GNOME asks which screen to share. Pick
the new monitor. Sunshine runs only while the Sidecar display is on, so GNOME's
screen sharing indicator is not shown otherwise. Do not start sunshine from a
terminal at the same time.
t2-sidecar off stops Sunshine and removes the monitor. Windows on it move back
to the built-in display. Locking the screen and logging out switch it off as
well.
Every t2-sidecar on creates a new virtual monitor, and GNOME does not apply a
saved screen choice to it. That is why the dialog comes up each time.
Moonlight settings#
- 1080p at 60 frames per second. 2560x1600 reached 50 to 60 frames per second in our tests over Wi-Fi 6 with a Snapdragon Android tablet.
- Video codec H.264 or automatic.
- Sound plays on the tablet while streaming. To keep it on the Mac, enable
playing audio on the PC in Moonlight's settings. To never stream sound from
any device, add
stream_audio = disabledtosunshine.conf.
Limitations#
Sunshine logs "Encoder did not produce IDR frame when requested" while streaming. The encoder returns frames asynchronously and Sunshine checks the wrong packet. Requested keyframes arrive on the requested frame.
Touch ID
KAIT2EN lets the finger you enrolled under macOS unlock the login screen and
confirm sudo on Linux. Nothing is enrolled on Linux. The Secure Enclave keeps
the fingerprint, compares it and sends Linux its verdict.
Prerequisites#
You need a finger enrolled under macOS, in System Settings > Touch ID. The macOS installer tells you if none is enrolled while you are still in macOS. Your macOS and Linux passwords do not have to match.
The Secure Enclave also needs a password to have unlocked its biometric keybag
once since the T2 itself last powered on. Rebooting the Mac does not power off
the T2, it only sleeps bridgeOS, so log into macOS once and it stays unlocked
across Linux reboots. A T2 panic or a power cut restarts the T2, and Touch ID
stays off until you log into macOS again with your password. If
journalctl -u kait2en-t2-touchid says no macOS user has a finger enrolled
although one is set up, this is why.
Binding#
Linux learns which enrolled finger the Secure Enclave saw, and fprintd remembers which of them belong to
your account. That binding is made without touching the sensor, because it is
only the statement that the macOS-enrolled fingers are yours, the same
assumption macOS itself makes. The finger still has to be on the sensor at
every login.
fprintd-list $USER shows the bound fingers. The sensor does not say which
finger a template is, so the labels are positional: the first is
right-index-finger, the second right-middle-finger, and so on. Fingers
enrolled under macOS later are bound the next time the bridge starts, for
example after a reboot.
Several users#
The bridge looks for the macOS user that has fingers enrolled by itself and
binds them to the Linux account that ran the installer. If that is not the
right pairing, edit /etc/kait2en/t2-touchid.conf: T2_TOUCHID_UID is the
macOS id (id -u under macOS, usually 501 or 502) and T2_TOUCHID_BIND_USER
the Linux account. Restart kait2en-t2-touchid afterwards. Any other Linux
user can bind a finger by hand with fprintd-enroll and a touch.
Turning it off#
sudo authselect disable-feature with-fingerprint
sudo systemctl disable --now kait2en-t2-touchid
Updating
KAIT2EN carries fixes until they are upstream. Merged fixes leave the repo. Until then, updates bring new module, app and installer versions.
Updating KAIT2EN#
Open a terminal and run:
kait2en-install
This updates the KAIT2EN Git checkout and runs the project installer. Reboot after it completes successfully.
If kait2en-install fails, clone the repo and run the installer from there:
git clone https://github.com/kaiT2en/KaiT2en-Fedora.git ~/KaiT2en-Fedora
cd ~/KaiT2en-Fedora/scripts/fedora
sudo ./install.sh
KaiT2en Update is an experimental app that installs only what changed. Multicall commands update only the modules or only the apps.
Updating Fedora#
Update Fedora as usual. DKMS rebuilds the KAIT2EN modules for each new kernel.
On Macs with the patched AMDGPU module (MacBookPro15,1, 16,1, 16,4, iMac20,1
and iMac20,2), a kernel-install hook also rebuilds AMDGPU for the new kernel.
It downloads the kernel source RPM, so it needs network access and adds a few
minutes to the update. dnf shows no output meanwhile. Reboot only after dnf has
finished. The build log is /var/log/kait2en-gpu-runtime-pm.log.
If that build failed, the new kernel boots with Fedora's stock AMDGPU. Rebuild it and reboot:
sudo /usr/local/libexec/kait2en/gpu-runtime-pm/install-gpu-runtime-pm.sh install <kernel>
sudo reboot
<kernel> is the new kernel version, for example uname -r after booting it.
See Configuring GPUs for details.
Kernel regressions are reported on Discord and Matrix.
Repairing a broken kernel update#
An interrupted DKMS build, for example by a reboot during the update, leaves incomplete modules for the new kernel. Boot an older kernel from GRUB and rebuild the new one:
# replace 7.1.3-201.fc44.x86_64 with the broken kernel version
sudo dracut --force /boot/initramfs-7.1.3-201.fc44.x86_64.img 7.1.3-201.fc44.x86_64
sudo kernel-install add 7.1.3-201.fc44.x86_64 /lib/modules/7.1.3-201.fc44.x86_64/vmlinuz
sudo grubby --set-default /boot/vmlinuz-7.1.3-201.fc44.x86_64
A faulty update can disable the internal keyboard and trackpad or Wi-Fi. Keep an external keyboard and mouse at hand when updating, for example while traveling.
When you can't boot at all#
If the system no longer boots or the input drivers are missing, boot the KAIT2EN USB drive into the live desktop and run:
sudo kait2en-rescue
The rescue tool finds and mounts your Fedora installation, chroots into it, and lets you rebuild the initramfs, verify the T2 input drivers or choose the default boot entry.
Multicall commands
KAIT2EN installs a helper script, kait2en-multicall, and links several short
commands to it. The command you type decides what runs. All of them are meant
to be started as your normal user without sudo. They ask for administrator
access when needed.
| Command | What it does |
|---|---|
edit-grub |
Opens /etc/default/grub in nano as root |
update-grub |
Regenerates /boot/grub2/grub.cfg |
boot-macos |
Restarts into macOS once. Linux is the default again on the next boot |
update-modules |
Updates the KAIT2EN checkout, then reinstalls the DKMS modules, rebuilds the patched AMDGPU driver on supported models and rebuilds the initramfs |
update-apps |
Updates the KAIT2EN checkout, then reinstalls the KAIT2EN applications |
Incremental updates#
update-modules and update-apps update only a part of the installation. They
are faster than kait2en-install, which runs all steps. Both reset the clean
checkout in /usr/local/src/KaiT2en-Fedora to the main branch of the remote
first, so they need the checkout that kait2en-install created.
update-modules
update-apps
Reboot after update-modules to load the updated modules. The AMDGPU step is
skipped on Macs that do not use the patched driver.
Run kait2en-install for everything else, see Updating.
Installed files
KAIT2EN keeps Fedora's vanilla kernel and installs T2 hardware support as a separate layer. The changes we are doing to your system are documented here to provide transparency to users and devs.
Repo location and updater#
The guided installer creates a clean git checkout of the main branch at:
/usr/local/src/KaiT2en-Fedora
Never change files in this directory manually unless you are told to.
kait2en-install fast-forwards this checkout and runs
scripts/fedora/install.sh. It refuses to overwrite local changes or use a
checkout with an unexpected Git remote. Its persistent files are:
/usr/local/bin/kait2en-install
/var/lib/kait2en-installer/state
~/.local/state/kait2en/install.log
Every installer step and app records the commit it was last installed from, one file per step or app:
/var/lib/kait2en-installer/applied/<step>
/var/lib/kait2en-installer/applied/app:<app>
The experimental KaiT2en Update app compares these records with GitHub. It
uses scripts/fedora/update-map from the checkout to tell which steps and
apps have to run again. See Updating.
Multicall commands#
install.sh installs a helper script and links the short commands to it. The
command name selects the action, see Multicall commands.
/usr/local/bin/kait2en-multicall
/usr/local/bin/edit-grub -> kait2en-multicall
/usr/local/bin/update-grub -> kait2en-multicall
/usr/local/bin/boot-macos -> kait2en-multicall
/usr/local/bin/update-modules -> kait2en-multicall
/usr/local/bin/update-apps -> kait2en-multicall
boot-macos writes the EFI BootNext variable and update-modules and
update-apps reset the checkout at /usr/local/src/KaiT2en-Fedora.
Kernel modules#
The installer copies each DKMS source package to /usr/src/<name>-<version>/,
registers it and builds it for the running Fedora kernel. DKMS keeps
its build state below /var/lib/dkms/ and rebuilds the modules for later
kernel updates. modinfo -n <module> prints the installed kernel object path.
| DKMS source | Installed module | Purpose |
|---|---|---|
apple-t2-bridge |
apple-t2-bridge |
T2 Bridge Controller: DMA queues, mailbox and power management |
apple-t2-bridge |
apple-t2-vhci-hcd |
Virtual USB host for internal T2 input devices |
apple-t2-bridge |
snd-apple-t2 |
Apple T2 audio driver |
apple-t2-bridge |
t2-ave |
Apple T2 AVE HEVC encoder |
apple-t2-bridge |
t2-sidecar |
Sidecar video encoder over the T2 NCM link |
t2smc |
t2smc |
Fan, temperature, charge-limit, RTC and SMC power limit access through hwmon |
t2bdrm |
t2bdrm |
Touch Bar DRM display device |
t2touchbar |
t2hid, t2touchbar_bl, t2touchbar_kbd |
Internal HID quirks, Touch Bar backlight and keyboard mode |
hid_t2magicmouse |
hid_t2magicmouse |
Internal trackpad support with the required Asahi patches |
t2_precision_trackpad |
t2_precision_trackpad |
Force Touch trackpad driver with dynamic surface geometry and a separate Force Click event |
t2_trackpad_actuator |
t2_trackpad_actuator |
T2 Force Touch actuator transport |
t2mfi_fastcharge |
t2mfi_fastcharge |
Fast-charge control for Apple MFi devices |
t2gmux |
t2gmux |
GMUX handling on dual-GPU Macs |
t2smp |
t2smp |
Defers secondary CPU hotplug to avoid firmware-sensitive resume delays |
t2sbs |
t2sbs |
Smart Battery driver that refreshes the full charge capacity and reports the charge relative to it, replaces sbs |
linux-apfs-rw |
apfs |
Read-only access to the macOS APFS container, vendored from upstream |
The installer also writes
/etc/kernel/install.d/39-kait2en-dkms-cleanup.install. The hook removes stale
DKMS build state before a kernel installation is retried.
On the MacBookPro15,1, MacBookPro16,1, MacBookPro16,4, iMac20,1 and iMac20,2, the installer also builds a patched AMDGPU module and installs it for the running kernel at:
/usr/lib/modules/<kernel>/updates/kait2en-gpu-runtime-pm/amdgpu.ko.xz
The corresponding modprobe configuration is installed as
/usr/lib/modprobe.d/kait2en-gpu-runtime-pm.conf.
Unlike the T2 modules above, this patched AMDGPU module is not built by DKMS.
Instead, the installer copies the build script and the patches to
/usr/local/libexec/kait2en/gpu-runtime-pm/ and writes
/etc/kernel/install.d/45-kait2en-gpu-runtime-pm.install. When Fedora installs
a new kernel, the hook builds the module for it after 40-dkms.install and
before 50-dracut.install, and logs to /var/log/kait2en-gpu-runtime-pm.log.
A failed build never aborts the kernel update. When a kernel is removed, the
hook deletes its module. To rebuild for a specific kernel by hand:
sudo /usr/local/libexec/kait2en/gpu-runtime-pm/install-gpu-runtime-pm.sh install <kernel>
Running the installer again refreshes the copy with the current patches.
On every MacBook and iMac with an Intel GPU, the installer also builds patched i915 and DRM display helper modules. They enable PSR on Apple panels and, on dual GPU T2 MacBook Pros, restore the panel brightness after the panel powers on:
/usr/lib/modules/<kernel>/updates/kait2en-i915/i915.ko.xz
/usr/lib/modules/<kernel>/updates/kait2en-i915/drm_display_helper.ko.xz
They are built the same way as the AMDGPU module. The build script and patches
live in /usr/local/libexec/kait2en/i915/, the hook is
/etc/kernel/install.d/47-kait2en-i915.install and logs to
/var/log/kait2en-i915.log. To rebuild for a specific kernel by hand:
sudo /usr/local/libexec/kait2en/i915/install-i915.sh install <kernel>
On T2 Macs with a Titan Ridge or Ice Lake Thunderbolt controller, the installer builds a patched thunderbolt module. On Titan Ridge it turns the idle controller off and back on through the same ACPI sequence as macOS, which lets the package reach the deep idle states.
/usr/lib/modules/<kernel>/updates/kait2en-thunderbolt/thunderbolt.ko.xz
The build script and patches live in /usr/local/libexec/kait2en/thunderbolt/,
the hook is /etc/kernel/install.d/47-kait2en-thunderbolt.install and logs to
/var/log/kait2en-thunderbolt.log. To rebuild for a specific kernel by hand:
sudo /usr/local/libexec/kait2en/thunderbolt/install-thunderbolt.sh install <kernel>
The patched AMDGPU, i915, thunderbolt and wireless modules are built from the Fedora kernel source, which is downloaded once per kernel and kept unpacked at:
/var/cache/kait2en/kernel-source/<kernel>/linux
/etc/kernel/install.d/44-kait2en-kernel-source.install prepares it for every
new kernel before the build hooks run, logs to
/var/log/kait2en-kernel-source.log and deletes it when the kernel is removed.
Its copy of the script lives in /usr/local/libexec/kait2en/kernel-source/.
On every Mac with Broadcom WLAN or Bluetooth, the installer also builds patched brcmfmac and Broadcom Bluetooth modules and installs them for the running kernel at:
/usr/lib/modules/<kernel>/updates/kait2en-wireless/brcmfmac.ko.xz
/usr/lib/modules/<kernel>/updates/kait2en-wireless/brcmfmac-wcc.ko.xz
/usr/lib/modules/<kernel>/updates/kait2en-wireless/brcmfmac-cyw.ko.xz
/usr/lib/modules/<kernel>/updates/kait2en-wireless/brcmfmac-bca.ko.xz
/usr/lib/modules/<kernel>/updates/kait2en-wireless/btbcm.ko.xz
/usr/lib/modules/<kernel>/updates/kait2en-wireless/hci_uart.ko.xz
/usr/lib/modules/<kernel>/updates/kait2en-wireless/hci_bcm4377.ko.xz
The build script and its patches are copied to
/usr/local/libexec/kait2en/wireless/, and
/etc/kernel/install.d/46-kait2en-wireless.install rebuilds the modules for
every new kernel after the GPU runtime PM hook. It logs to
/var/log/kait2en-wireless.log, never aborts the kernel update and deletes the
modules of a removed kernel. To rebuild for a specific kernel by hand:
sudo /usr/local/libexec/kait2en/wireless/install-wireless.sh install <kernel>
Kernel arguments#
install-kernel-args.sh updates every installed kernel entry with
grubby --update-kernel=ALL. Inspect the effective arguments with:
grubby --info=DEFAULT
KAIT2EN adds these arguments to every installed kernel through grubby:
amdgpu.aspm=1
i915.enable_guc=2
intel_iommu=on
iommu=pt
pm_async=off
pcie_aspm=force
pcie_aspm.policy=powersave
pci=noaer
mem_sleep_default=deep
initcall_blacklist=cmos_init,magicmouse_driver_init
module_blacklist=acpi_tad,applesmc,macsmc,hid_apple,hid_appletb_bl,hid_appletb_kbd,hid_magicmouse,appletbdrm,apple_bce,apple_mfi_fastcharge,apple_gmux,sbs
On iMacs and the iMac Pro, pcie_aspm=force is left out, because their
Ethernet controllers do not work with forced ASPM.
pcie_ports=compat is no longer set and is removed from existing installs.
The PCIe port services stay on, so hotplug and PCIe tunnels over Thunderbolt
work and the Thunderbolt root ports can enter D3 at runtime.
On every T2 Mac, the installer enables HuC firmware loading for the Intel GPU:
i915.enable_guc=2
The value is a bitmask: 2 selects. HuC is
used by Intel media workloads, including HEVC operations.
KAIT2EN does not install a custom kernel or a separate GRUB configuration file.
Audio configuration#
install-alsa-ucm.sh installs the ALSA UCM profiles for the T2 speaker,
microphone and headset paths from modules/apple-t2-alsa-ucm-conf/ucm2/:
/usr/share/alsa/ucm2/AppleT2/HiFi-x2.conf
/usr/share/alsa/ucm2/AppleT2/HiFi-x4.conf
/usr/share/alsa/ucm2/AppleT2/HiFi-x6.conf
/usr/share/alsa/ucm2/conf.d/AppleT2x2/AppleT2x2.conf
/usr/share/alsa/ucm2/conf.d/AppleT2x4/AppleT2x4.conf
/usr/share/alsa/ucm2/conf.d/AppleT2x6/AppleT2x6.conf
It also backs up and resets the stored WirePlumber profile, node and route
defaults of the T2 card in ~/.local/state/wireplumber/, with backups named
*.kait2en.bak.
The t2-dsp package and install-dsp.sh install all DSP profiles and the
runtime integration:
/usr/share/t2-dsp/profiles/<profile>/
/usr/share/t2-dsp/pipewire/<profile>.conf
/usr/share/t2-dsp/models.json
/usr/share/wireplumber/wireplumber.conf.d/51-t2-dsp.conf
/usr/share/wireplumber/scripts/t2-default-output.lua
/usr/lib/udev/rules.d/89-t2-dsp.rules
/usr/libexec/t2-dsp/package-actions
/usr/libexec/t2-dsp/lifecycle.py
/usr/share/licenses/t2-dsp/
The package scripts and install-dsp.sh generate these files during
installation:
/etc/pipewire/pipewire.conf.d/51-t2-dsp.conf
/var/lib/kait2en/ownership/t2-dsp.json
/var/lib/kait2en/migration/t2-dsp/
/var/log/t2-dsp-install.log
51-t2-dsp.conf is a copy of /usr/share/t2-dsp/pipewire/<profile>.conf,
selected from the DMI product name. migration/t2-dsp/ holds backups of
retired files from earlier installs. See Audio DSP
for the supported-model table, audio behavior and diagnostics.
System configuration and services#
| Path | Purpose |
|---|---|
/etc/systemd/system/kait2en-suspend.service |
Calls the suspend helper before sleep.target and again after resume |
/usr/local/libexec/kait2en/kait2en-suspend.sh |
Handles the BCM4350 suspend workaround described below |
/etc/systemd/system/kait2en-macos-mount.service |
Mounts the readable macOS volumes read-only under /media/macOS at boot |
/usr/local/libexec/kait2en/kait2en-macos-mount |
Finds the readable volumes in the internal APFS container and mounts them as subdirectories by role |
/etc/udev/rules.d/90-kait2en-macos.rules |
Hides the internal APFS partition from file managers, the volumes are reached through /media/macOS |
/etc/systemd/system/t2-services-suspend.service |
Runs feature sleep/resume hooks around sleep |
/usr/local/libexec/t2-services/t2-ncm-sleep |
Runs installed feature hooks before sleep and after resume |
/usr/local/libexec/t2-services/sleep.d/t2-ave |
Closes/reopens sessions only when the AVE daemon is running |
/etc/systemd/system/kait2en-t2-remote.service |
Loads t2-ave and runs t2remote, which holds the bridgeOS services Linux uses, currently com.apple.aveservice for the video encoder |
/usr/local/bin/t2remote |
RemoteXPC service manager; t2remote status shows the live services. Listens on /run/t2remote.sock |
/etc/NetworkManager/conf.d/10-t2-services.conf |
Keeps NetworkManager away from the internal CDC-NCM interface to the T2, so it stays up until the suspend hooks have closed their T2 sessions. Replaces the former Apple T2 Bridge profile |
/usr/local/lib/udev/rules.d/90-t2-services-ncm.rules |
Brings the internal CDC-NCM interface up with an IPv6 link-local address |
/etc/modprobe.d/kait2en-silent-blacklist.conf |
Silently ignores attempts to load drivers replaced by KAIT2EN modules |
/usr/share/plymouth/themes/kait2en/ |
Boot splash in the KaiT2en Vornehm style, the silver kanji above a slim progress bar |
/etc/plymouth/plymouthd.conf |
Selects the KAIT2EN theme, pins DeviceScale=1 and sets UseSimpledrm=0 so the splash does not resize when i915 replaces the 2880x1800 EFI framebuffer |
/usr/share/pixmaps/kait2en-gdm-logo.png |
Silver and red KAIT2EN logo shown by GDM |
/etc/dconf/db/gdm.d/00-kait2en |
Configures the GDM logo and solid black login background |
/usr/share/backgrounds/kait2en/gdm-black.png |
Black GDM background image |
/usr/share/gnome-shell/gnome-shell-theme.gresource |
GNOME Shell theme patched so the GDM and lock-screen shield render black and the login controls get the KaiT2en Vornehm glass |
/etc/dracut.conf.d/90-kait2en-input.conf |
Keeps the internal keyboard drivers, t2smc and t2sbs in initramfs images built during kernel updates |
/boot/initramfs-<running-kernel>.img |
Rebuilt by Dracut after modules and ACPI handling are complete |
kait2en-suspend.service is enabled on every installation. Before suspend, it
checks for the BCM4350 WLAN chip of the MacBookPro14,1 (vendor ID 0x14e4,
device ID 0x43a3). If it is present, it unloads brcmfmac_wcc and brcmfmac,
and after resume it loads them again.
The BCM4377 needs no unload. Its WLAN and Bluetooth drivers load the firmware again after S3 themselves.
Without a BCM4350, the service logs that the fix is not needed and does not
unload a module. State files for modules successfully unloaded by
the helper exist only until resume below /run/kait2en-suspend/.
The installer checks the running kernel log for two known Apple ACPI firmware
errors. It only deploys an override when the error is present and the generated
table passes validation with iasl:
/usr/local/lib/firmware/acpi/*.aml
/usr/local/lib/firmware/acpi/.kait2en-*.sha256
/etc/dracut.conf.d/t2-acpi-fix.conf
/var/backups/t2-acpi-fix/<timestamp>/
The backup contains every managed file that existed before deployment and a manifest. KAIT2EN only replaces or removes an ACPI table when its ownership marker contains the table's current SHA-256 checksum. Existing unmarked tables and modified managed tables are left unchanged and reported as conflicts.
kait2en-macos-mount.service is enabled on every installation. At boot the
helper loads apfs and reads the volume list and the encryption flags from the
container superblock of every internal APFS partition. Each unencrypted volume
is probed read-only in turn. Every readable volume is mounted as a subdirectory of the
single /media/macOS directory, named by the role detected from its contents,
so the whole macOS install is browsed from one place:
| Mount point | Volume | Detected by |
|---|---|---|
/media/macOS/System |
System | System/Library/CoreServices/SystemVersion.plist |
/media/macOS/Preboot |
Preboot | */restore/BuildManifest.plist or */cryptex1 |
/media/macOS/iSCPreboot |
iSCPreboot | nvram.plist with a Firmware/ directory |
/media/macOS/Recovery |
Recovery | signed boot objects */*.im4m |
The probe runs on every boot because the volume order differs between Macs and
macOS versions. The macOS Data volume is encrypted and stays unmounted, and the
VM volume is left out. /media/macOS itself is a small tmpfs marked
x-gvfs-show, and the volume mounts are marked x-gvfs-hide, so file managers
list one macOS entry with the volumes as folders.
Apple firmware from the installer USB drive#
The guided installer copies Apple's own firmware for this Mac from the USB drive into the installed system, renamed to the file names the Linux drivers ask for:
/usr/lib/firmware/brcm/brcmfmac<chip>-pcie.apple,<board>*
Macs with the BCM4377 PCIe Bluetooth controller (14e4:5fa0) additionally get
the two Bluetooth blobs. Every other T2 Mac drives Bluetooth over UART and gets
nothing here:
/usr/lib/firmware/brcm/brcmbt<chip><stepping>-apple,<board>[-<vendor>].bin
/usr/lib/firmware/brcm/brcmbt<chip><stepping>-apple,<board>[-<vendor>].ptb
The exact names are taken from what the driver asked for in the kernel log. The outcome of the Bluetooth step is recorded in the installed system at:
/var/log/kait2en/bluetooth-firmware.log
Applications#
t2-fan-control, t2-smc-control, t2-power-explorer, t2-debug, t2-airshare,
t2-drop, t2-zone-power, t2-journal, t2-kbd-backlight, kait2en-touchbar, kernel-builder,
t2-power-tune, t2-truetone and kait2en-update are installed system-wide under /usr/local. kait2en-touchbar
is optional and only installed when selected at the start of the installation.
t2-truetone is installed with GNOME on the T2 MacBooks, the iMac20,1 and
the iMac Pro.
MacBookPro15,1, MacBookPro16,1 and MacBookPro16,4 get
t2-hybrid-gpu-control; other MacBook Pro models with Intel and AMD display
devices get t2-dgpu-control.
All KAIT2EN desktop applications use the shared header wordmark at
/usr/local/share/kait2en/kait2en-wordmark.png in the dark style and
/usr/local/share/kait2en/kait2en-wordmark-light.png in the light style.
| Application | Installed files |
|---|---|
| T2 Fan Control | /usr/local/bin/t2-fancontrol-gtk, /usr/local/share/applications/org.t2fancontrol.gtk.desktop, /usr/local/share/icons/hicolor/scalable/apps/org.t2fancontrol.gtk.svg, /usr/local/lib/systemd/system/t2-fancontrol.service |
| T2 SMC Control | /usr/local/bin/t2-smc-control, /usr/local/share/applications/org.t2smccontrol.gtk.desktop, /usr/local/share/icons/hicolor/scalable/apps/org.t2smccontrol.gtk.svg, /usr/local/lib/systemd/system/t2-smc-gaugingd.service, /var/lib/t2-smc-control/gauging |
| T2 Power Explorer | /usr/local/bin/t2-power-explorer, /usr/local/libexec/t2-power-explorer-status, /usr/local/share/applications/org.t2powerexplorer.gtk.desktop, /usr/local/share/icons/hicolor/scalable/apps/org.t2powerexplorer.gtk.svg, /usr/share/polkit-1/actions/org.t2powerexplorer.policy |
| T2 Journal | /usr/local/bin/t2journal |
| T2 Zone Power | /usr/local/bin/t2-zonepower-gtk, /usr/local/share/applications/org.t2zonepower.gtk.desktop, /usr/local/share/icons/hicolor/scalable/apps/org.t2zonepower.gtk.svg, /usr/local/lib/systemd/system/t2-zonepowerd.service |
| T2 Kernel Builder | /usr/local/bin/t2-kernel-builder, /usr/local/libexec/t2-kernel-builder-cleanup, /usr/local/libexec/t2-kernel-builder/build.sh, /usr/local/libexec/t2-kernel-builder/configs/*.config, /usr/local/share/applications/org.t2kernelbuilder.gtk.desktop, /usr/local/share/icons/hicolor/scalable/apps/org.t2kernelbuilder.gtk.svg, /usr/local/share/polkit-1/actions/org.t2kernelbuilder.gtk.policy |
| T2 Power Tune | /usr/local/bin/t2-power-tune, /usr/local/libexec/t2-power-tune-helper, /usr/local/libexec/t2-power-tune-status, /usr/local/share/applications/org.t2powertune.gtk.desktop, /usr/local/share/icons/hicolor/scalable/apps/org.t2powertune.gtk.svg, /usr/share/polkit-1/actions/org.t2powertune.policy |
| T2 Force Click | /usr/local/bin/t2-force-click, /usr/local/share/applications/org.t2forceclick.gtk.desktop, /usr/local/share/icons/hicolor/scalable/apps/org.t2forceclick.gtk.svg, /usr/local/lib/systemd/system/t2-force-click.service |
| KaiT2en Update | /usr/local/bin/kait2en-update, /usr/local/libexec/kait2en-update-helper, /usr/local/share/applications/org.kait2enupdate.gtk.desktop, /usr/local/share/icons/hicolor/scalable/apps/org.kait2enupdate.gtk.svg, /usr/share/polkit-1/actions/org.kait2enupdate.policy |
| T2 Debug | /usr/local/bin/t2-debug, /usr/local/bin/t2debug, /usr/local/share/applications/org.t2debug.gtk.desktop, /usr/local/share/icons/hicolor/scalable/apps/org.t2debug.gtk.svg |
| T2 AirShare | /usr/local/bin/t2-airshare, /usr/local/bin/t2airshare, /usr/local/share/applications/org.t2airshare.gtk.desktop, /usr/local/share/icons/hicolor/scalable/apps/org.t2airshare.gtk.svg, /usr/local/lib/systemd/user/t2-airshare.service, /usr/local/share/applications/org.t2airshare.send.desktop, /usr/local/share/kio/servicemenus/t2-airshare-send.desktop, /usr/local/share/nemo/actions/t2-airshare-send.nemo_action, /usr/local/share/nautilus-python/extensions/t2-airshare-send.py, /usr/local/share/licenses/t2-airshare/, per user ~/.config/t2-airshare/config.toml. On systems with Nautilus the package nautilus-python |
| T2 Drop, the AirDrop service of T2 AirShare | /usr/local/bin/t2drop, /usr/local/lib/systemd/system/t2-drop.service (started by D-Bus activation), /usr/share/dbus-1/system.d/org.t2drop.conf, /usr/local/share/dbus-1/system-services/org.t2drop.service |
| T2 Keyboard Backlight | /usr/local/bin/t2-kbd-backlight, /usr/local/lib/systemd/system/t2-kbd-backlight.service, /etc/kait2en/kbd-backlight.toml. MacBooks only |
| T2 Touch Bar | /usr/local/bin/kait2en-touchbar, /usr/local/lib/systemd/user/kait2en-touchbar.service, /usr/local/lib/systemd/system/kait2en-touchbar-attach.service, /usr/local/lib/udev/rules.d/99-zz-kait2en-touchbar.rules, /etc/kait2en/touchbar.toml, /usr/local/share/licenses/kait2en-touchbar/THIRD-PARTY-NOTICES.md |
| T2 TrueTone | /usr/local/bin/t2-truetone, /usr/local/bin/t2truetone, /usr/local/share/applications/org.t2truetone.gtk.desktop, /usr/local/share/icons/hicolor/scalable/apps/org.t2truetone.gtk.svg, /usr/local/lib/systemd/user/t2-truetone.service (enabled per user by the app), /usr/local/lib/udev/rules.d/70-t2-truetone.rules, /usr/local/share/gnome-shell/extensions/kait2en-autobrightness@kait2en/, per user ~/.config/t2-truetone/config.toml, ~/.local/state/t2-truetone/base-lut, ~/.local/state/t2-truetone/brightness/curve and, while the GNOME features are off, ~/.local/state/t2-truetone/saved-night-light-enabled and ~/.local/state/t2-truetone/brightness/gnome-settings |
| T2 Hybrid GPU Control | /usr/local/bin/t2-hybrid-gpu-control, /usr/local/libexec/t2-hybrid-gpu-control-helper, /usr/local/libexec/t2-hybrid-gpu-control-status, /usr/local/share/applications/org.t2hybridgpucontrol.gtk.desktop, /usr/local/share/icons/hicolor/scalable/apps/org.t2hybridgpucontrol.gtk.svg, /usr/share/polkit-1/actions/org.t2hybridgpucontrol.gtk.policy, /usr/share/polkit-1/actions/org.t2hybridgpucontrol.gtk.status.policy, /etc/environment.d/90-kait2en-gsk-renderer.conf, /boot/efi/EFI/kait2en/t2-gpu-preboot.efi, the UEFI boot entry KaiT2en GPU, the EFI variable boot-gpu-cf9aa22b-9505-4c88-aed0-5673e31b00c2 and the build package rust-std-static-x86_64-unknown-uefi |
| T2 GPU Control | /usr/local/bin/t2-dgpu-control, /usr/local/libexec/t2-dgpu-control-helper, /usr/local/libexec/t2-dgpu-control-status, /usr/local/share/applications/org.t2dgpucontrol.gtk.desktop, /usr/local/share/icons/hicolor/scalable/apps/org.t2dgpucontrol.gtk.svg, /usr/local/lib/systemd/system/kait2en-dgpu-off.service, /usr/local/lib/systemd/system/kait2en-dgpu-suspend.service, /usr/local/lib/systemd/system/kait2en-amdgpu-profile.service, /usr/local/lib/systemd/system/kait2en-amdgpu-profile-resume.service, /usr/share/polkit-1/actions/org.t2dgpucontrol.gtk.policy, /usr/share/polkit-1/actions/org.t2dgpucontrol.gtk.status.policy |
T2 Fan Control's service starts immediately and persists fan curves across
boot and resume. t2-drop.service is not enabled. D-Bus starts it when
T2 AirShare receives or sends over AirDrop, it runs as root because AWDL needs
CAP_NET_ADMIN, stays while T2 AirShare is visible and exits a minute after
the last caller. T2 Hybrid GPU Control does not install system services.
Enabling hybrid graphics puts its KaiT2en GPU boot entry first in
BootOrder, ahead of Fedora's shim entry. Uninstalling the app removes the
entry, the EFI image and the variable.
T2 GPU Control enables its units only when the corresponding options are
applied in the app. Both privileged helpers validate the GPU layout and accept
only the fixed operations exposed by their UI.
T2 Force Click persists its settings at /etc/t2-force-click/config.txt; its
root daemon listens at /run/t2-force-click/daemon.sock, which is runtime
state and disappears at shutdown. While the driver is loaded, its user-facing
controls are:
/sys/module/t2_precision_trackpad/parameters/click_strength
/sys/module/t2_precision_trackpad/parameters/force_click_threshold_percent
/sys/module/t2_precision_trackpad/parameters/force_click_enabled
T2 trackpad actuator playback#
t2_trackpad_actuator exposes the DTrace-captured Taptic Engine click
waveforms to privileged local software. A third-party helper can play the
light or firm impulse by writing one of these values:
printf light | sudo tee /sys/module/t2_trackpad_actuator/parameters/play
printf firm | sudo tee /sys/module/t2_trackpad_actuator/parameters/play
The interface accepts no raw waveform bytes. light and firm select the
captured reports used by the precision trackpad driver. Callers should trigger
individual application events and rate-limit repeated playback themselves.
The parameter is write-only and requires the module to be loaded and bound to
the T2 actuator interface.
Each report takes about 6 ms over the T2 USB transport. While a waveform still plays, the actuator stalls the next report. The module then resends it once, as macOS does, so a stall only shows up in the kernel log when the retry fails as well. Shorter waveforms allow denser sequences.
For diagnostics, root can compose a waveform through the probe_* parameters
and play it with test_fire=9. Every amplitude is capped at 70, the
AmplitudeMax the actuator reports to macOS. macOS itself sends plain
Gaussian clicks with amplitudes between 9 and 38.
T2 Power Tune reads package C-state residency and exposes PCIe ASPM, runtime
power management, LTR ignore, and additional power tunables. The optional
/etc/systemd/system/kait2en-power-tune.service is created by the app only when
the user chooses persistent settings. Its runtime selection cache is stored at
/run/t2-power-tune/items.json and disappears on reboot.
T2 Journal stores the last successfully parsed BridgeOS log snapshot and a cache of recently discovered RemoteXPC ports for each desktop user:
~/.local/state/t2-journal/bridgeos.jsonl
~/.local/state/t2-journal/remote-ports
$XDG_STATE_HOME replaces ~/.local/state when it is set. The snapshot is
created on the first query or explicit refresh and is atomically replaced only
after a successful download and parse. See T2 Journal
for the required network setup.
T2 Kernel Builder keeps downloaded sources, build trees and completed-build
markers below $XDG_CACHE_HOME/t2-kernel-builder/build (normally
~/.cache/t2-kernel-builder/build) and its saved UI state below
$XDG_CONFIG_HOME/t2-kernel-builder (normally ~/.config/t2-kernel-builder).
Kernels installed through the app add their normal files below /boot and
/lib/modules/<kernel>/; package-managed builds are installed through DNF.
The installer builds all KaiT2en Rust apps and services into one shared Cargo
target directory at ~/.cache/kait2en/cargo-target of the user who invoked
sudo. The apps share their GTK dependencies there, and updates rebuild only
what changed. Deleting the directory is safe. The next installer run rebuilds
it.
