Part of POCO guides, 2025 guides.

Rooting without a PC sounds like a party trick. It is not. It is the same flash

you would do from a laptop, just moved onto hardware you already carry. Two

Android devices, one cable, one file transfer, and no driver hunting on Windows.

I picked KernelSU over Magisk for a boring reason. It keeps root in the kernel,

stays quieter about it, and apps that sniff around for the usual root leftovers

tend to miss it. Magisk still works fine if that is your habit, and nothing below

changes much if you prefer it.

The part that actually matters is the init_boot file, and it has to match your

firmware build exactly. Mismatch it and you are heading straight into a boot loop.

What you need

• The KernelSU app. Use the patched build linked below, because plain store

versions will not patch cleanly.

• init_boot.img from your own firmware. In this video the build is

20.202.0.VOJINX, and yours has to match your phone.

• Termux set up with the recovery tool on a second Android device, with USB

debugging switched on.

• Quick Share, Telegram or WhatsApp to move files between the two phones.
• Your data backed up, because you are rooting, not lucky.

How the flow works, in plain words

This is the part that feels strange the first time. You are not flashing from the

laptop. You are pulling the boot image off your own firmware, sending it to the

phone, letting the KernelSU app patch it, sending the patched copy back to the

device that runs Termux, and flashing it from there with the phone plugged in over

USB. Two Android devices, one cable.

Once you have done it once, it is a ten minute job.

Step 1 - install KernelSU and open it once

Install the patched KernelSU build and open it one time so it sets itself up.

Do not skip that first launch.

Step 2 - get your own init_boot.img

Take init_boot.img out of your own fastboot ROM or recovery package. Not someone

else's upload, not a file from a guide about a different build. Yours.

Check the firmware version while you are in there. If it does not match what is on

the phone, stop and download the right package, because flashing a mismatched

boot image is the classic boot loop.

Step 2b - a quick sanity note before you commit

If you are unsure which firmware you are on, check it in Settings and compare it

against the package name before you extract anything. Two minutes here saves an

evening later.

Step 3 - patch init_boot in KernelSU

Send init_boot.img to the phone, open KernelSU, choose Install, pick the file,

and hit Start. It writes a patched copy. Leave it in the Download folder so you

know exactly where it is.

Step 4 - send the patched file to the Termux device

Move the patched image back to the second Android device with Quick Share,

Telegram or whatever you already use. Drop it in the Download folder there too,

because the Termux command you paste expects to find it there.

Step 5 - run the flash tool from Termux

Open Termux, paste the cd command from the video, then run the flash tool. It

walks the flashing for you, which is the whole reason this works without a laptop.

Step 6 - connect the phone and confirm it is seen

Connect the phone over USB with USB debugging on. The tool should list the device

before it flashes anything. If it reports nothing, that is almost always a

charge-only cable or debugging left off, not a broken tool.

Step 7 - flash, reboot, confirm root

Flash the patched init_boot, reboot, and open KernelSU. It should show root as

live. If it does not, the patched file and the firmware build do not match, so go

back to Step 2 with the correct init_boot.img.

Where people get stuck

• Flashing an init_boot from a different firmware build. The version has to

match yours, no exceptions. This is the single most common failure here.

• USB debugging switched off, so the tool reports no device and people blame

the cable.

• A charge-only cable. Same dead end, just with extra frustration and a

longer troubleshooting session.

• Using the plain store KernelSU build, which will not patch cleanly.

KernelSU or Magisk

Both give you root. KernelSU keeps it in the kernel, which is why I picked it

here: apps that sniff around for the usual root leftovers tend to miss it, and it

stays quieter. Magisk still works fine and has the bigger ecosystem of modules. If

you already know Magisk, there is no reason to change. If you are starting fresh

on this phone, KernelSU is the tidier choice.

One honest note: rooting breaks Play Integrity on most setups, and banking apps

often care. That is not a bug in this method, it is what root does. If your bank

app is non-negotiable, think about that before you flash.

If the driver or tooling side is what puts you off, the free Rom Flasher tool on

GitHub handles the ADB and fastboot driver install in a couple of clicks. It is

free, and the link is in the downloads section.

Full description from the video

Rooting the POCO X7 Pro with Termux and KernelSU — no PC in the whole chain. KernelSU vs Magisk, the patched init_boot, and the exact order I did it in.

I went with KernelSU instead of Magisk for a boring reason: it keeps root in the kernel, stays quieter about it, and apps that sniff around for the usual root leftovers tend to miss it. Magisk still works fine if that's your habit. The part that actually matters here is the init_boot file, and it has to match your firmware build or you're heading straight into a boot loop.

The flow is strange the first time and simple after that. You pull init_boot.img out of your own fastboot ROM, send it to the phone, patch it inside the KernelSU app, send the patched file back to the Android device that runs Termux, and flash it from there. Two Android devices, a Quick Share transfer, no drivers on a PC, no long cable. It's the same trick as flashing from a laptop, just moved onto hardware you already carry.

📱 Device : POCO X7 Pro (also works on most Android phones)

🧩 Root : KernelSU (patched build) or Magisk

📦 init_boot: 20.202.0.VOJINX

🛠️ What You Need

• The KernelSU app — use the patched build linked below, plain Play Store versions won't patch cleanly
• init_boot.img from your own firmware, 20.202.0.VOJINX in this video
• Termux set up with the recovery tool, and USB debugging switched on
• A second Android phone or tablet to run Termux from
• Quick Share, Telegram or WhatsApp to move files between the two
• Your data backed up, because you're rooted, not lucky

📝 Steps

1. Install KernelSU and open it once.
2. Take init_boot.img out of your fastboot ROM or recovery package.
3. Send it to the phone and patch it in KernelSU — Install, pick the file, Start.
4. Send the patched file back to the Termux device, into the Download folder.
5. Open Termux, paste the cd command, then run the flash tool.
6. Connect your phone over USB with debugging on and confirm the tool lists it.
7. Flash the patched init_boot, reboot, open KernelSU and confirm root is live.

⚠️ Where People Get Stuck

• Flashing an init_boot from a different firmware build — the version has to match yours.
• Leaving USB debugging off, so the tool reports no device and people blame the cable.
• Using a charge-only cable, which is the same dead end with extra frustration.

❓ Common Questions

Is this really without a PC? Yes. Termux does the flashing, the second Android device is just the terminal.

Do I need an unlocked bootloader? Always, and unlocking wipes your data, so back up first.

KernelSU or Magisk? KernelSU here, because it's the safer default for apps that look for root.

Common questions

More for POCO X7 Pro