The device is a Xiaomi 13 (fuxi), HyperOS 3, build number OS3.0.309.0.WMCCNXM, kernel 5.15.194, security patch 2026-08-01. There is only one goal: skip the 168-hour wait and get the BL unlocked.

Conclusion first: in the end it came down to a domestic tool from 2026, using a temporary kernel root to write an engineering abl into both slots, then booting into fastboot to run the unlock.

Three approaches were tried before this one: two finished tools failed on the spot, and a downgrade approach stalled halfway through. I’m writing it down because the “why it doesn’t work” of each step is more useful than the “how to do it”.

Starting point: 309 and a swapped wrapper

The Xiaomi 13 in hand (fuxi) runs HyperOS 3, build number OS3.0.309.0.WMCCNXM, kernel 5.15.194, security patch 2026-08-01.

The standard route to unlock the BL is “wait 168 hours + answer the quiz” — slow but certain. To get around it, the community has two ideas: spoof device info during the application to fool the check, or push an old version of “Settings” back into the system partition so the application entry point reverts to a version without the wrapper.

Both finished tools take the second route: HyperSploit and MlgmXyysd’s Bypass. Both failed, and not because they were used wrong. Both were written in 2023 against the old wrapper; 309 replaced the RSA wrapper, the client has no matching private key, and the tools themselves report “patched” or throw parameter errors. The only workaround they offer is “roll back to the old Settings”.

The three walls hit when rolling back Settings

This route is also dead on 309, and all three walls break at once:

  1. The old package’s versionCode is 34, while the system has 36 installed. pm install -d and -r -d are all rejected as a “downgrade”.
  2. Changing the version number means touching the APK, which changes the signature; and Settings is a system app that only accepts the official signature, so installing the modified build throws are not updateable.
  3. What about getting root and overwriting it directly? /system_ext is a read-only partition protected by dm-verity. From a root shell, cmd package can’t reach the package service, and there’s no way to “let the system install it itself”.

At this point the device is still stock and boots normally — not bricked. Stopping matters more than forcing it.

A zero-write approach, and an approach that gambles the motherboard

After stopping, I went back to researching and found two completely different paths.

One is to stuff selinux=permissive into the boot parameters. Specifically fastboot oem set-gpu-preemption-value ... selinux=permissive, then fastboot continue, then a string of service call to change the system properties in memory and restart zygote.

Its advantage is solid: it writes no partition at all — the parameters live in memory and vanish on reboot. The worst case is that getprop still prints 309 and the properties stay unchanged; the ceiling of risk is one wasted attempt. The downside is equally clear: the author tested on a HyperOS 2 machine, and commenters already report that “the commands stop working after the 2026 patch”.

The other is unauthorized deep flashing over 9008. Before taking it, one criterion has to be read first, because it doesn’t hold for every device:

8Gen2 only supports tool-based unlocking on the February 2026 patch and below; for higher versions, only if the flash is not Kioxia and 9008 is not blown, go the 9008 deep-flash route.

Ours is a September patch, so check the flash first: THGJFJT2T85BAT0C — Kioxia.

So the 9008 verdict becomes: it’s viable, but it falls under “if you’re still in warranty, just gamble; if it bricks, send it to service for a motherboard swap”. For a daily driver you’ve only just gotten comfortable with, that’s a cost worth a separate decision, not something to try on a whim.

So the order became: try the zero-write one first, and only then decide whether to gamble.

The right answer: write abl, but only abl

Later I found JiGuang-8Gen2-tool. It’s a different kind of thing from the two tools above:

  • It explicitly supports fuxi;
  • It explicitly says Kioxia works too;
  • The flow is: push ships its own abl + preload for privilege escalation → set permissive in fastboot → continue back into the system → under root, dd writes abl_a/abl_b → flash the unlock image.

It writes the abl partition, not an EDL deep flash. abl is the bootloader itself, and dd two commands bring it back, so the brick risk is an order of magnitude lower than 9008; and once unlocking is done, a system update restores the official abl, ending the engineering abl’s mission — the unlock state lives in another partition and doesn’t depend on it.

The code is a modified version by @御坂114515号 on Coolapk, with the author info left in the script header. The package comes from GitHub, a 167 MB 7z that unpacks to 1.4 GB and contains a full toolchain with two device directories, images/fuxi and images/sheng.

Neither of the two stalls was a technical problem

The first run stopped at “requires clean Enforcing”. An earlier manual privilege escalation had left SELinux in enforce=0, so the tool judged the environment unclean and exited immediately.

The fix was simple: reboot once. abl hadn’t been touched yet, so rebooting was safe; after getting back into the system I ran it again, this time enforce=1, and only then did it proceed.
(This is part 1 of 2 of the same post.)

The second issue is the driver. The toolkit only ships adb.exe and fastboot.exe, not the drivers, and Win11 doesn’t include them either. While the device shows a yellow exclamation mark in Device Manager, adb devices is empty. It only gets recognized after installing MiFlash (which bundles the Xiaomi USB / QDLoader drivers). Here’s a counterintuitive point: don’t use Zadig to switch the device to WinUSB — fastboot becomes unstable.

There’s also a note on pacing: the script runs from push to abl write as one continuous chain, and a manual reboot midway will break it at whatever state it’s in. It will ask on screen to “hold Power + Volume Down to enter fastboot” — do that step, then don’t touch anything.

Both slots must be written

At the dd step, the tool writes both abl_a and abl_b.

Writing only one slot won’t cause immediate problems, but the other slot still holds the official abl, and after unlocking, switching slots will run into inconsistent bootloaders between the two slots. To do it by hand:

ls -l /data/local/tmp/abl.elf
dd if=/data/local/tmp/abl.elf of=/dev/block/by-name/abl_a bs=4096 conv=fsync
dd if=/data/local/tmp/abl.elf of=/dev/block/by-name/abl_b bs=4096 conv=fsync
sync

First run ls to confirm the file is there (200-something KB), and only then dd.

Wrapping up

After a successful unlock: flash.locked=0, unlocked: yes, the orange warning, and a 5-second wait at boot. Data is wiped.

Looking back, the ordering of these four paths is really by “whether a bad write can be recovered”: zero writes > abl write > EDL deep flash. A finished tool failing doesn’t mean the approach fails — it just proves that deciding which partition to touch this time matters more than finding a tool that runs.

One more thing has to go here: unlock state is persistent, so don’t casually lock it back — locking and then unlocking again means going through the whole process from the start.

FAQ

Q: Can HyperSploit or Bypass still be used on OS3.0.309?
No. Both tools target the old 2023 packaging; 309 switched to RSA packaging, the client has no matching private key, and running them only produces patched or parameter errors.

Q: I’m afraid to touch 9008 — is writing only abl safe?
It’s an order of magnitude lower risk than 9008. abl is the bootloader itself, and dd two commands bring it back; after unlocking is complete, system updates will also write the official abl back, and unlock state doesn’t depend on it.

Q: Does unlocking wipe data? How long does it take?
Yes, unlocking inevitably wipes data, so back up first. Wait time depends on the method: the engineering abl path takes about a dozen minutes from start to finish, plus first boot and formatting.