TopGit
GitHub Repo Review

NeoZygisk: Zygote injection module for APatch & KernelSU

JingMatrix/NeoZygisk
NTopGit review image for JingMatrix/NeoZygisk
Review by Topgit.dev for JingMatrix/NeoZygisk, with GitHub repository stats and README context.
Quick verdict

NeoZygisk brings Zygote injection to APatch and KernelSU, which lack native Zygisk support, while replacing Magisk's built-in Zygisk with a DenyList that actively unmounts traces from zygote instead of relying solely on namespace switching. On newer Android where traces run deeper, this matters. The catch: Magisk's Enforce DenyList must be off or it fights NeoZygisk's own stealth logic, and the unmount path is experimental. For APatch and KernelSU users, this is the only way to run Zygisk modules at all.

Stars
★ 2.6k
Forks
⑂ 227
Contributors
👥 6
Language
C++
License
GPL-3.0
Topic
Mobile
Updated
Nov 2026
Homepage
—
GitHub

What is NeoZygisk?

NeoZygisk is a C++ Zygote injection module implemented via ptrace that adds Zygisk API support to APatch and KernelSU, and also functions as a Magisk Zygisk replacement. It provides full API compatibility with Magisk's built-in Zygisk, with its own DenyList logic layered on top.

Core features

  • ✓Full Zygisk API compatibility with Magisk's built-in Zygisk — modules targeting Magisk's API work on APatch and KernelSU through NeoZygisk
  • ✓ptrace-based injection — the module attaches to zygote and injects its logic at the right moment in the app forking process
  • ✓Dual stealth strategy: experimental direct unmount from zygote (with safety checks) plus reliable setns-based namespace switching as fallback
  • ✓DenyList controls mount namespaces per application — granted apps see root and module mounts, DenyList apps see a clean namespace
  • ✓Experimental direct unmount from zygote — removes traces before an app process fully specializes, potentially more thorough than namespace switching alone
  • ✓DenyList cleanup — when all Zygisk modules are unloaded, NeoZygisk guarantees traces are removed from application processes
How this repository's GitHub stars have grown over time. Source: star-history.com.View the star history ↗

What NeoZygisk is used for

  • •Running Magisk Zygisk modules on APatch or KernelSU, which have no native Zygisk support
  • •Replacing Magisk's built-in Zygisk for users who want NeoZygisk's more aggressive DenyList implementation
  • •Hiding root from apps that perform mount-based detection — DenyList apps see no root or module mounts
  • •Module authors supporting multiple root solutions who need a consistent Zygisk API surface across APatch, KernelSU, and Magisk
  • •Trusted apps that need full root access while keeping other apps clean — DenyList configures per-app namespace visibility

Installing NeoZygisk

NeoZygisk is a Magisk module distributed as a flashable ZIP or through host app module managers compatible with APatch, KernelSU, or Magisk. Installation involves flashing the module through the host root solution's module management UI. No standalone APK or separate app is required — once installed it activates inside the host. KernelSU users will need a GUI app (such as KernelSU Manager) to configure the DenyList for target applications.

Strengths

  • ✓Provides Zygisk API support where it does not exist natively — the only path for Zygisk modules on APatch and KernelSU
  • ✓Full API compatibility with Magisk's built-in Zygisk, so existing module code works without modification
  • ✓C++ implementation keeps the footprint lean and avoids unnecessary overhead in the injection path
  • ✓Experimental direct unmount from zygote provides a potentially more hidden stealth surface than namespace switching alone
  • ✓Safety check aborts direct unmount if a module provides critical system resources, preventing zygote crashes
  • ✓DenyList cleanup guarantees removal of injection traces once all modules are unloaded

Limitations and conflicts

  • △No standalone UI — DenyList configuration relies entirely on the host app's interface, which varies between APatch, KernelSU, and Magisk
  • △Direct unmount from zygote is experimental and not guaranteed to work in all configurations — the setns fallback is the reliable path
  • △Magisk's Enforce DenyList option conflicts with NeoZygisk's own DenyList and must be disabled — a non-obvious requirement for Magisk users
  • △APatch and KernelSU compatibility depends on those platforms maintaining compatible APIs — any upstream changes in those root solutions can break the integration
  • △The experimental unmount path has no fallback if the safety check triggers on a module that provides critical resources — it silently falls through to setns

Alternatives to NeoZygisk

Frequently asked questions

Is NeoZygisk compatible with Magisk?

Yes, NeoZygisk works alongside Magisk as a replacement for its built-in Zygisk. Magisk's Enforce DenyList option must be disabled, as that separate DenyList implementation conflicts with NeoZygisk's own stealth logic.

What is the difference between NeoZygisk and Magisk's built-in Zygisk?

Magisk's Zygisk hides traces through namespace switching after an app forks. NeoZygisk adds an experimental direct unmount from the zygote process itself before the app fully specializes, plus retains the setns fallback. The DenyList implementation is more active in NeoZygisk.

Does NeoZygisk work with APatch and KernelSU?

Yes, and it is essential on those platforms — APatch and KernelSU do not include native Zygisk support, so NeoZygisk is the bridge that lets Zygisk modules run on either solution.

What does the NeoZygisk DenyList do?

The DenyList controls which mount namespace an app sees. Granted apps see root and module mounts. Apps on the DenyList get a clean mount namespace with all root traces hidden. NeoZygisk achieves this via setns switching, with an experimental path that unmounts traces directly from zygote.

Why should Magisk users disable Enforce DenyList when using NeoZygisk?

Magisk's Enforce DenyList runs a separate implementation that does not guarantee full mount trace hiding. It conflicts with NeoZygisk's own DenyList logic, so both cannot run simultaneously. NeoZygisk's DenyList handles everything when enabled in the host app.

How does NeoZygisk hide root traces from apps?

NeoZygisk uses ptrace to attach to the zygote process and inject its logic before apps fork. For DenyList apps it either unmounts root traces directly from zygote (experimental, with a safety check) or switches the forked app into a cached clean mount namespace via setns.

The problem it solves

APatch and KernelSU do not include Zygisk, which means the ecosystem of Magisk modules built on the Zygisk API cannot run on those platforms. Module authors who want to support all three root solutions face fragmentation — they need a separate implementation path for each. NeoZygisk resolves this by providing the missing Zygisk API surface on APatch and KernelSU.

Who should try it — and who should skip

APatch and KernelSU users who need Zygisk modules should install NeoZygisk — it is the only way to run that ecosystem on those platforms. Magisk users who want a more aggressive DenyList should consider it, but only if they are comfortable disabling Magisk's own Enforce DenyList. Stock Android users and anyone not running a systemless root solution get nothing from this. If you do not need Zygisk modules, the install complexity is not worth it.

Related repositories

Source & attribution

Source: https://github.com/JingMatrix/NeoZygisk

GitHub data · last synced Oct 12, 2026Reviewed by Henry
← Back to TopGit

Is NeoZygisk worth your time?

ChatGPT, Claude and Perplexity can all read this page. Ask one of them what it makes of NeoZygisk.

GitHub