NyaZygisk WebUI Guide: What Each Feature Does and How to Use It

2000 words
10 minutes
NyaZygisk WebUI Guide: What Each Feature Does and How to Use It

After installing NyaZygisk you can check whether it is working, and turn Zygisk modules off for a single app, without opening a terminal. Both are done in the module’s built-in WebUI. This post goes through every section: what it shows, where the data comes from, and what each switch changes.

The short version: the WebUI has just two tabs, Overview (status, modules, three settings) and App exclusion (pick apps that should not load modules). Day to day you will mostly use the second one.

Note

This post is based on the NyaZygisk repository: the frontend in module/src/webroot/, and the zygiskd and loader code that reads the settings. I did not re-test every item on a device while writing it, and UI strings are taken from the source. If your version differs from the description, trust what you see on screen.


🚪 How to open it#

  1. In your root manager (KernelSU / APatch), find NyaZygisk on the modules page and tap its WebUI entry (usually an “Open” button or a web icon on the module card).
  2. Magisk itself has no WebUI entry, so you need a third-party manager that supports WebUI. The frontend recognizes these bridge interfaces: window.kernelsu, KernelSU, WebUIX, apatch, and mmrl. If none of them is found, the page shows “No supported WebUI bridge detected”.

All data is obtained by running shell commands as root through the manager’s exec interface. It does not use the network, so it works offline.


📊 Tab 1: Overview#

Header: version and reload#

The small text under the title is NyaZygisk version · root solution and version. The circular arrow at the top right is Reload. It re-reads all status and reloads the app list, then shows “Reloaded” at the bottom.

Status card: is Zygisk actually working?#

The big card at the top gives a verdict with a color and icon, and lists three components below it:

ComponentMeaning
Zygote monitorThe monitor component that watches the Zygote process and performs injection; if it is stopped, nothing gets injected
Zygote (labelled 64-bit / 32-bit)Whether the Zygote process has been injected
Daemonzygiskd, which serves files, companions, and so on to modules

Each component’s status falls into one of three groups:

  • Good (green): Running, Injected, Tracing
  • Bad (red): Stopped, Exited, Crashed, Not injected
  • Other (gray): Unknown

The verdict on the big card follows this rule, which is the frontend’s overallTone logic:

CardConditionWhat to do
✅ All systems workingAll three components are goodNothing
⚠️ Partially workingMonitor and Zygote are fine, but another component is bad (usually the daemon)Modules may not load; reload, then reboot
❌ Not workingThe monitor or Zygote is badZygisk is not active; reboot, and if it persists, collect debug logs and report it
❔ Status unknownStatus could not be read, or the module was just installed and not rebooted yetCheck again after a reboot; if a bridge error also appears, use a manager that supports WebUI
Tip

After installing and rebooting, the first thing to do is open the WebUI and look at this card. It is also the last step in the README’s install instructions.

Device & environment#

This card lists:

  • Root: detects APatch / FolkPatch / KernelSU / Magisk and shows the version when it can get one. It checks the apd, fpd, and magiskd processes and the /data/adb/ksu directory. SukiSU and similar show up as KernelSU or SukiSU.
  • System: only shown when a vendor ROM is detected. ColorOS / OxygenOS, HyperOS, MIUI, and One UI are recognized, with versions taken from each vendor’s system properties. On AOSP-like systems this tile is hidden.
  • Kernel, Android SDK, ABI: read directly from the data the daemon reports.

When filing an issue, attaching a screenshot of this card is the quickest way to share your environment.

Active modules#

Lists the Zygisk and ZN modules that are currently enabled. The number at the top right is the total. Each module shows its name, version, description, author, and badges:

  • Zygisk: a module using the Magisk Zygisk API (for example LSPosed)
  • ZN: a module using the Zygisk Next API. If its target is not zygote, a “Target: xxx” line is added
  • Companion: the module uses a companion process

The list merges two sources:

  1. A scan of /data/adb/modules/*, skipping directories with a disable or remove marker and keeping only those that contain zygisk/<abi>.so or zn_modules.txt. Its module.prop is read for the details.
  2. The module list reported by the daemon, which adds the type (Zygisk / ZN), target, and companion information.

So if a module is missing here, first check whether it is disabled, or whether it is a Zygisk module at all (no zygisk/ directory and no zn_modules.txt). Conversely, a module you just enabled but have not rebooted for may already be in the list without actually being loaded; go by the state after a reboot.

Settings#

Anonymous memory: “Hide module mappings after specialization”. Off by default.

When on, after an app process has been specialized, NyaZygisk turns the module-created entries in /proc/self/maps (private mappings whose path contains jit-cache-zygisk, zygisk-module, or zn-module) into anonymous mappings, and removes write permission from rwx mappings. The goal is that an app scanning its maps does not see names that identify the modules.

  • Useful when: an app scans maps for Zygisk traces and you have confirmed you need this.
  • Leave it off when: you have no such need. It changes the process’s memory attributes, and users have reported problems after turning it on, such as the system UI failing to start or the status showing Monitor: NO. If you see anything like that, turn it off first to check whether it is the cause.
  • The change is saved immediately and applies to app processes started afterwards. Apps that are already running need a restart.

Custom linker: “Load modules without the system linker (experimental)”. Off by default.

Normally modules are loaded by the system dynamic linker (android_dlopen_ext), which records them in its solist. With this switch on, NyaZygisk instead uses its own built-in ELF loader to map the module into memory and apply its relocations, so the module never enters the system linker’s records. Combined with anonymous memory it can map straight into anonymous pages, leaving no memfd name behind.

  • Useful when: you want fewer module traces in the system linker and accept the risk of an experimental feature.
  • Leave it off when: you just want a normal setup. It is experimental, which is why it is not enabled by default. If loading fails or a module is unsupported, NyaZygisk falls back to the system linker automatically; but if you see crashes or misbehaving modules after turning it on, turn it off before reporting.
  • It also applies to app processes started afterwards. To see which loader loaded a module, use the debug build and look for modloader: lines in the log.
  • Since v2.5-r2 a missing key means off. Earlier versions treated a missing key as on, so if you still want it after updating, turn it on again in the WebUI.

Language: EN / 繁中 / 简中. It takes effect immediately and is remembered in the WebUI’s own local storage; it does not affect the module itself.


🛡️ Tab 2: App exclusion#

This is the most practical feature in the WebUI: checked apps load no Zygisk modules at all.

Typical cases:

  • An app refuses to run or bans you when it detects Zygisk or hooks, and you do not need any module’s features in it.
  • A module crashes one particular app, and you would rather exclude that app than disable the whole module.

How to use it#

  1. Switch to the App exclusion tab at the bottom (the number on the tab is the count of currently excluded apps).
  2. Find the app:
    • the search box matches name or package name;
    • the “All N / Excluded N” filter lets you show only excluded apps.
  3. Turn on the switch at the right of the app. Every toggle is saved immediately, with a “Saved” toast.
  4. Restart that app (swipe it out of recents completely, then open it). The exclusion only takes effect the next time the app starts; processes that are already running are not affected. Entries not yet in effect show a “Pending restart” badge.

Excluded entries are sorted first, the rest by name. Rows do not jump around when you toggle, so ticking several in a row will not hit the wrong one.

“Unmount for excluded apps”#

The switch at the top of the tab (Unmount for excluded apps) is on by default.

  • On: besides not loading modules, an excluded app also has root and module mounts removed from its mount namespace, like the DenyList.
  • Off: modules are simply not loaded; mount traces are left alone.

In other words, with this switch on, excluding an app means “modules cannot get in, and the app cannot see the mounts either”. If you already handle the app with your root manager’s “Umount modules” option (APatch / KernelSU) or Magisk’s DenyList, this switch runs alongside them without conflict.

Important

App exclusion is not the same as the DenyList. The DenyList deals with mounts (Zygisk modules are still loaded); app exclusion deals with module loading (plus optional unmounting). To keep an app fully isolated from modules, use app exclusion and leave “Unmount for excluded apps” on.

Limitations#

The hint at the top of the page already says some of this; here it is in full:

  • Only user-installed apps are listed (pm list packages -3). System apps do not appear and cannot be excluded. This is deliberate: system_server and system UIDs are never affected, so you cannot break the system with it.
  • Apps sharing a UID switch together. If several packages share one UID, excluding one excludes all of them, and the list shows “Shares its UID with N other package(s); they switch together”.
  • Apps sharing a UID with a system package cannot be excluded. Their switch is grayed out with the note “Shares a UID with a system package; cannot be excluded”. The daemon only excludes a UID when every package on it is on the list, and system packages are not allowed on the list.
  • Uninstalled packages are cleaned out automatically, so there are no invisible leftover entries.
  • Showing app names needs the manager to provide a package info interface (KernelSU-style WebUIs do). Without it only package names are shown, and functionality is unaffected.

🧰 Troubleshooting#

SymptomLikely cause and fix
Everything shows - and “Status unknown”, with a “No supported WebUI bridge detected” toastThe manager does not provide the exec interface. Use the entry built into KernelSU / APatch, or a third-party manager that supports WebUI
Status is “Partially working”The daemon did not start. Reload, then reboot; if it persists, collect logs with the debug build
“Not working”Zygisk is not active. Make sure no other Zygisk implementation (NeoZygisk, ReZygisk, Zygisk Next) is installed; on Magisk, turn off the built-in Zygisk
The module list is emptyNo module is enabled, or none of them is a Zygisk / ZN module
An app still loads modules after being excludedThe app was not restarted, or it shares a UID with a system package (the switch is grayed out)
“Failed to save setting” toastWriting config.prop failed and the switch snaps back. Check that the manager gives the WebUI root access

🔧 For advanced users: where settings are stored#

All WebUI settings are written to one file:

/data/adb/nyazygisk/config.prop
KeyValueMeaning
anonymous_memory1 / 0Anonymous memory; a missing key means off
custom_linker1 / 0Custom linker; a missing key means off (only 1 enables it)
exclude_unmount1 / 0Unmount for excluded apps; a missing key means on
exclude_appspkg1,pkg2,...Excluded package names, comma separated

When writing, the WebUI changes only its own key and keeps the rest, writing to a temporary file and then renaming it so a half-written file is never read. The daemon watches the file’s modification time and flushes its cache when it changes, so you do not need to restart the daemon; editing the file by hand outside the WebUI works too (again, for processes started afterwards).


Summary#

  • After installing, check the status card on Overview first: green means Zygisk is working.
  • The module list tells you whether your modules were actually recognized, and as which type.
  • App exclusion is the main day-to-day feature: tick the app, then restart it. Keep “Unmount for excluded apps” on if you also want the mounts hidden.
  • Anonymous memory is only needed when an app scans its maps.
  • Custom linker is experimental and off by default; if something breaks after turning it on, turn it off before reporting.

If the description does not match the actual behavior, or there is a feature you want, open an issue on GitHub or tell us in the Telegram channel @NyaZygisk.

Support & Share

If this article helped you, please share or support!

Sponsor
NyaZygisk WebUI Guide: What Each Feature Does and How to Use It
https://www.nkbe.top/posts/nyazygisk-webui-guide/
Author
NkBe
Published at
2026-10-21
Table of Contents