MaxManager

What this is: the first release of MaxManager — a control panel for rooted Android phones. Works on: Android 10 or newer · Magisk, KernelSU or KernelSU Next Download: MaxManager-v1.0-module.zip — flash it in your root manager. Its checksums are the second file. Since this is 1.0, everything below is new. There is no earlier version to compare against.


In one minute

MaxManager helps you make a rooted phone smoother, cooler, or longer-lasting — and it only offers you settings your phone can actually do.

That sounds obvious, but it is the whole point. Most tuning apps give you hundreds of switches, and half of them do nothing on your phone. MaxManager looks at your phone first, so:


What is inside 1.0 — the whole list

# Area In one line
1 Profiles Five one-tap behaviours you can apply, tune, save and share — and switch from Quick Settings
2 Nine control areas CPU, GPU, memory, display, responsiveness, thermal, power, storage & compiler, network
3 One app at a time Give one app its own profile, refresh rate, resolution, thermal ceiling and governors
4 Charging & battery health Charge ceiling, current limits, bypass charging, doze, battery health
5 The on-screen panel FPS, frame time, CPU, RAM, power, battery heat and renderer over any game — four looks
6 What is running now Process list with CPU and RAM per app, force-stop, SIGKILL, a floating panel
7 Logs & diagnostics Live logs with search, route health for every control, a device blueprint, a report you choose to send
8 The tools shelf Property editor, activity launcher, root file manager, permissions, backups, freezing, plugins, module health
9 Look and language Themes, a colour scheme, 84 languages, real right-to-left support
10 Max Atlas Finds what your phone supports — and proves what it does not have
11 Max AI Off by default: changes one thing, measures whether it helped, remembers
12 The safeties One write path, read-back verification, undo, and a list it never touches

Where to start

You do not need all 53 screens. These five cover what most people want:

If you are… Open this And you get
Just want a better phone Profiles (home screen or Quick Settings) Cooler and calmer, in one tap
Playing games Apps → your game → Gaming Its own settings; nothing else on the phone changes
Curious about the numbers FPS panel and Home Live readings over your game and inside the app
Charging overnight Control → Power → charging Less battery wear over time
Into the details Control (the nine areas) and Control → Tools Everything else

Everything else is there when you want it — nothing is missing, it is just not shouting at you.


Profiles — one tap, and what a profile really is

A profile is a named set of behaviour you can apply, tune, save and share:

Two things make profiles more than bookmarks:


The nine control areas — everything you can change

Nine areas, each in its own hub. The line in italics is the app’s own one-line description of that area.

CPU — cores, governor, vendor boost and kernel preferences

GPU — GPU frequencies and graphics-specific vendor parameters

Memory — compression, VM behaviour and swappiness

The engine reads memory stall pressure, not fill percentage: a nearly-full-but-idle phone and a phone that is actually stalling need opposite responses, and the app tells them apart.

Display — refresh rate, colour and canvas scale

Responsiveness — touch, frame pacing and scheduling latency

Thermal — temperatures, throttling and thermal parameters

The safety limits themselves are never written — that is the one rule this project does not bend.

Power — charging, bypass, sleep and battery health

Storage & compiler — compilation mode and storage health

Anything your device does not expose in one of these areas is simply not listed. No dead switches.


One app at a time — per-app control

Open Apps, pick an app, and give it its own treatment without touching the rest of the system:

Every app shows its effective state in plain words: per-app control is off · using the global profile · app override active. While a game with its own profile is in front, Max AI switches to monitoring only and stops changing things.

There is also a screen for debloat and freeze, and “why didn’t it work?” for a per-app setting: what it wanted, what the hardware is holding, and where to look next.


The panel over your game

A floating readout you can drag anywhere over any game. It does not cover your whole screen, and it does not steal frames.

What it can show — you choose; only the fields you want appear:

Four looks, for four different kinds of player:

Look What it is like
Strip A thin single-line bar along the top or bottom edge
Pane A small multi-line box, the classic “overlay in the corner”
Ring A circular gauge with the headline number in the middle
Badge The desktop-style look: one big number, its unit on the text baseline, frame time underneath

And three more things:


What is running right now — the process monitor


Watching, measuring, diagnosing


The tools shelf

Under Control → Tools — tools you open on purpose, not preferences to browse. The riskier ones are labelled as advanced.

Tool What it does
Property editor Reads and writes Android properties. It keeps a journal of every change — with the old value next to the new one — lets you filter to what you changed, and can put an old value back in one tap. When a value is 0/1 or true/false it gives you a switch instead of a text box; and it writes back the exact form the phone used, because getprop and Settings spell the same value differently and “normalising” one would corrupt a perfectly good key
Activity launcher Opens any activity on the device, including ones your launcher hides
File manager A root file browser: browse, inspect, copy, move and delete with the permissions you actually have
Permissions & AppOps What an app declares, what the platform allows, and a documented reference to check against
Max Backup Back up an app, verify the backup, and restore it
Debloat & freeze Freeze or remove pre-installed apps you do not want running
Plugins The third-party contract: which add-ons are installed, what was accepted, what was refused, and why
Module health Is the module installed correctly, and are its pieces alive
Privilege Confirms the app really has the privileged access it needs
Config backup Export and import the app’s own settings
Diagnostics The diagnostic centre described above

Advanced tools that write outside MaxManager’s own settings are marked on purpose — not to lock you out, but so a list of switches is never mistaken for a casual one.


Look and language


Max Atlas — the reason anything works on your phone

Two phones of the same model can expose different kernel interfaces; two kernels can name the same interface in different units and let you write it or not. Max Atlas asks every interface whether it is here, what it is called, what unit it speaks, whether it can be written — and remembers the answer.

  1. Controls that cannot work are not shown.
  2. Every control is labelled for what it is: works and verified here · a route exists but is unproven here · readable only · present but this build cannot drive it · proved absent · never touch (a safety rule) · or unknown.
  3. Absence is proved, not assumed. A read that failed is not an absence; only a listing that genuinely lacks a name counts as “not here”.
  4. It gets better on your device. What worked, what failed, and how long either fact stays true are remembered — the second run is not the same experiment as the first.

Discovery runs under an explicit budget, and when a bound stops a scan the report says a limit stopped it — never “the device had nothing to say”. A real run on a phone can be recorded and replayed through the same read interface, so “it needs a device” stops being a permanent excuse.


Max AI — one measured change at a time

Max AI watches how the device is actually behaving — speed, heat, battery, memory pressure, which app is in front — and when the readings say something should change, it changes one thing, then measures whether that helped. It is a loop, not a preset:

Why it is not a preset: a preset applies the same numbers to every device and never finds out whether it helped. Max AI only speaks the vocabulary Max Atlas found on your phone, its wins are measured rather than predicted, and it knows when to stop. Each cycle is kept as a record you can open: what it saw, what it wanted, what it changed, what happened next, what it learned.

It is off until you turn it on, and the profile you choose stays a manual baseline — never an instruction to the engine.


What it will never do

That last one is the structural promise: whatever you change — by hand or by the engine — goes through the same path, is read back, and is re-checked afterwards.


Why it never slows your phone down

The heavy work is not in the app — it runs in five small programs written in Rust, shipped for both 64-bit and 32-bit phones (ten executables in the package):

sys.maxmanager-service (the device service) · sys.maxmanager-rianixiathermalcore (thermal daemon) · sys.maxmanager-utilityconf · sys.maxmanager-profilesettings · sys.maxmanager-preloadbin

The intended result is an app that behaves as if it were not there: open it when you need it, and nothing underneath steals frames from your game.

And the honest part: we promise no performance numbers and no benchmark deltas. A number measured on one phone is not a claim about yours — what we claim is the structure above, which you can inspect.


Install in three steps

  1. Flash MaxManager-v1.0-module.zip in Magisk or KernelSU.
  2. Reboot.
  3. Open MaxManager and follow the first screen — it explains what your phone supports.

It is a systemless module: nothing in /system is changed permanently, and removing it puts everything back. If the module ever fails to boot properly twice in a row, it turns itself off and says so, so you never end up with a phone that will not start because of it.


Two promises we do not break

  1. We do not guess. A value the app could not read is shown as unknown, never as a plausible zero. Yes, you will sometimes see “unknown” — that is honesty, not a broken feature.
  2. We do not touch what must not be touched. Thermal safety limits are never written, on any phone, and a protected list of interfaces is refused even when the automation is on.

If something looks wrong


Appendix

For engineers: what is verified, and the numbers | Item | Value | | --- | --- | | Package | the app installed as a privileged system app, with its permission file, the module scripts, and ten native executables (five programs × 64-bit and 32-bit) | | Native layer | 5 Rust programs · 53 Rust files · 9,638 lines | | App | 424 Kotlin files · 114,015 lines | | Screens | 53 screens across nine control domains, plus the tools shelf | | Tests | 1,709 Kotlin tests · 77 Rust tests, run on the host without a device | | Contract gates | 34 commands on every push, before the build — plus a second layer verifying JNI symbols inside the real `.so` files | | Architecture decisions | 54 documented decisions, binding on the code | | Languages | 84 locales · 3,581 keys · 97% average coverage | **The limit, stated the way this project states it:** anything that depends on real hardware — touch, boot, SELinux, the module install, thermal response — is verified on a device, and where a run cannot be made the repository says *“not verified in this environment”* instead of “passes”. That is a rule here, not a hedge.
For ROM developers The integration kit is **released to ROM maintainers on written request** — Soong build files, an init service, a sepolicy domain and a privileged-permission allowlist, plus the same module packaged for KernelSU Next. **You get:** a privileged control app, the five native binaries, and a module that installs and removes itself without permanently touching `/system`. **You need:** a platform-signed, privileged build of the app; the daemon at `/system/bin/sys.maxmanager-service`; the init service; and the sepolicy rules. Three names must agree exactly — the binary path, the init service and the SELinux label. > **Permission first.** MaxManager is **proprietary software**. The kit is here so maintainers can > evaluate and integrate it with the copyright holder’s written permission.
Verify your download | Asset | Size | | --- | --- | | `MaxManager-v1.0-module.zip` | 15.3 MB | | `MaxManager-checksums.txt` | 28 lines — the package digest plus 27 for its contents | ```sh # 1) the file you downloaded sha256sum -c --ignore-missing MaxManager-checksums.txt # 2) what is inside it, after unpacking unzip -q MaxManager-v1.0-module.zip -d maxmanager && cd maxmanager sha256sum -c --ignore-missing ../MaxManager-checksums.txt ``` The same package is built by CI on every push, with the developer bundle and checksums attached as workflow artifacts.
Credits, licence and support MaxManager is not written alone. These are the works it thanks — every notice their licences require stays in [`THIRD_PARTY_NOTICES.md`](../../THIRD_PARTY_NOTICES.md), which remains the binding list. | Project | Copyright | Licence | | --- | --- | --- | | [AZenith](https://github.com/Liliya2727/AZenith) | (C) 2025-2026 Zexshia | Apache-2.0 | | [Encore Tweaks](https://github.com/Rem01Gaming/encore) | (C) 2024-2025 Rem01Gaming | Apache-2.0 | | [Rianixia-ThermalCore](https://github.com/ryanistr/Rianixia-ThermalCore) | (C) 2025-2026 ryanistr | Apache-2.0 | | [VMTouch](https://github.com/hoytech/vmtouch) | (c) 2009-2023 Doug Hoyte and contributors | BSD-3-Clause | **Licence:** proprietary. Copyright (C) 2026 **Nader Magdy**. All rights reserved — no right is granted to use, copy, modify or distribute without the copyright holder’s prior written permission. A public repository is not the same thing as an open-source project. **Support:** [@MaxManagerChat](https://t.me/MaxManagerChat)