BooxUltimatum

How it works

What BooxUltimatum asks of the tablet, part by part, with the file it lives in and the test behind it.

Tablet
Boox Note Air6 COne unit, the maintainer's
Firmware
4.3, Android 162026-08-17_12-29_4.3-rel_0817_fd4f8e9fe
Status
Verified on one tablet, reported on othersOwners report Instant ink on a Go 10.3 Lumi, a Note Air 2 Plus and a NoteX3 Pro, and Shizuku tweaks on a Go 10.3 and a Note Air4 C. The table of tablets has the rest. Boox's interfaces are unofficial, so an update can change them.

Access tiers, and why no root

Every feature and tweak declares the least access it needs, and BooxUltimatum still works without more, with fewer features. A tweak's tier is part of its definition in code, and BooxUltimatum checks it before offering the change.

TierWhat it isWhat it unlocks
T0Just BooxUltimatum, as installedBooxUltimatum home, the sleep screen (Sleep image mode) and the power-off screen, Instant ink, battery measurement, changing the font of the whole tablet, the Settings hub (shortcuts to Android's and Boox's own settings), and becoming your home app through Android's own confirmation. For apps Boox restricts, links to Android's battery page and to Boox's hidden App Freeze page.
T1Permissions you grant once from a computer with adb, Android's debugging tool, over USBReading battery statistics in BooxUltimatum, showing or hiding status bar icons on the whole tablet, and setting-based tweaks
T2Shizuku: a separate app that runs a small service with the rights of the shell user (uid 2000), the same rights as adb, without a computerMost tweaks, reading and lifting Boox's background restriction for every app, one-tap home switching, the network name in the header, Sleep now, and the Over Transparent sleep mode (without Shizuku it needs one permission from Android, described below)
T3Root, full administrator access to AndroidNot needed: BooxUltimatum works without it. The project decided on 2026-09-25 to aim no higher than T2.

The one-off T1 grants, run once from a computer connected to the tablet:

adb shell pm grant app.booxultimatum android.permission.WRITE_SECURE_SETTINGS
adb shell pm grant app.booxultimatum android.permission.DUMP
adb shell pm grant app.booxultimatum android.permission.READ_LOGS
adb shell pm grant app.booxultimatum android.permission.READ_DROPBOX_DATA
adb shell appops set app.booxultimatum GET_USAGE_STATS allow

On Android 16, READ_DROPBOX_DATA lets BooxUltimatum read the system's dropbox, where a restart of Android is recorded. Older firmware doesn't define that permission and doesn't need its line. The last line allows usage access, which tells BooxUltimatum which app is in front. The repository bundles these as scripts. tools/host/grant-permissions.ps1 (or .sh) grants T1 once, and tools/host/start-shizuku.ps1 (or .sh) starts Shizuku after each reboot. Shizuku needs adb to start, and firmware 4.3 hides the Wireless debugging switch, so for now starting it takes a computer.

T1 can show or hide status bar icons on the whole tablet (icon_blacklist). The custom Wi-Fi and battery designs are drawn only in BooxUltimatum home's own header. Replacing the artwork of the system's icons would need a system overlay, and the shell user can't create one (cmd overlay fabricate answers "must be root").

For T2, BooxUltimatum binds a Shizuku user service (ShellService, over AIDL, Android's way for two processes to talk) that runs commands as the shell user. That helper costs about 66 MB. While BooxUltimatum is your home app its process never ends, so it unbinds the service and removes the helper's process after 45 seconds without calls. Shizuku itself stops on every reboot. With the tablet plugged into a computer, tools\host\start-shizuku.ps1 restarts it. Firmware 4.3 hides Wireless debugging, so restarting it from the tablet alone isn't possible yet.

Why no root

On older Boox models the bootloader, the program that starts Android and decides which software may load, shipped unlocked. On the Note Air6 C it doesn't. A capture from the maintainer's Note Air6 C reads verifiedbootstate=green, flash.locked=1 and vbmeta.device_state=locked, with ro.oem_unlock_supported empty and SELinux, Android's access-control layer, enforcing. No public firehose loader, the program a Qualcomm chip needs before it accepts a flash in emergency mode, is known for its Qualcomm QCS6690 either. Root isn't a given, so on 2026-09-25 the project decided to aim for T0 to T2 and nothing above. BooxUltimatum flashes nothing, touches no system partition and leaves the bootloader locked.

The limit is real and sometimes costs a feature. Android 16 refuses shell writes to DeviceConfig flags, its store of system tuning values, outside its allowlist. So a planned Enter deep sleep sooner tweak was dropped rather than shipped broken.

The home screen's resource budget

BooxUltimatum home had one hard requirement besides being good: it must never compete with the Boox home for memory or CPU. It was measured on a Note Air6 C on 2026-09-26 with dumpsys meminfo, a memory report, and top -d 15, CPU use refreshed every 15 seconds, while each home showed its home screen. PSS is the memory a process holds, with shared memory split between the processes that use it:

BooxUltimatum homeBoox home (com.onyx)
Memory (PSS), in front64 to 132 MB, about 60 MB of it window buffers just after start455 MB
Memory (PSS), behind29 to 44 MBn/a
CPU while idle on home0.0 %0.2 %

The figures come from choices, not from luck:

  • No polling. BooxUltimatum home registers its receivers and the network callback only between onStart and onStop, which is while it is visible. The page refreshes on ACTION_TIME_TICK and on battery and connectivity broadcasts while visible, and on package callbacks.
  • An 8 MB icon cache, trimmed when the UI is hidden.
  • The wallpaper decoded at half resolution in RGB_565, a 16-bit colour format, and only when the file changes.
  • Widget hosting that listens only while visible. Weather is refreshed only while visible and at most hourly.
  • The Shizuku helper released after 45 seconds of idle.

Compatible by construction

BooxUltimatum home uses only Android's public APIs for home apps: LauncherApps for apps, shortcuts and badged icons, and AppWidgetHost for widgets. It uses no reflection and no hidden APIs. Packages that Boox froze are invisible to LauncherApps, although stock Boox still opens them. So the All apps list finds their launch entry directly and shows them dimmed with a frozen tag, instead of leaving them out. Recents belong to com.android.onyxquickstep. Gestures, NaviBall (Boox's floating button) and EinkWise (Boox's per-app e-ink settings) belong to SystemUI, so they behave the same under either home app. BooxUltimatum home ships disabled, as a HOME alias that you turn on, and the Boox home is journaled before the first switch. From a computer, this command always brings it back:

adb shell cmd package set-home-activity --user 0 com.onyx/.StartupActivity

Verified on a Note Air6 C with BooxUltimatum home as the default home app: the Home and Back buttons, app shortcuts, the Boox entry points (Library, Notes, Storage), Recents, and recovery after the process is killed.

The sleep screen

Boox's sleep screen is an Android doze dream, the screen shown while the tablet dozes: com.onyx/com.onyx.common.dream.OnyxDaydreamService. Its style and pictures live in com.onyx's private MMKV storage, which no other app can read or write. But the always-running com.onyx process has a dynamic, exported receiver that needs no permission. It listens for a broadcast, a message any app can send, and Boox Settings uses it too:

am broadcast -a onyx.action.SCREENSAVER \
  --ei type 16 \
  --es file '/storage/emulated/0/Pictures/booxultimatum-sleep.png' \
  --ez show_result_hint false

Type 16 switches the style to Image, with that file as its only picture. This broadcast is part of Onyx's public SDK (ScreenSaverUtils, used by OnyxAndroidDemo's screensaver sample), and other open-source apps such as KOReader cover tools use it too. BooxUltimatum sends it from its own app uid, its own Android identity, which was verified on a Note Air6 C, so Sleep image mode is T0. With Shizuku it repeats the broadcast from the shell. Restore sends type 16 with Boox's own /system/media/standby-1.png, because the previous style can't be read back, and offers Boox's screensaver settings beside it. BooxUltimatum never sends the broadcast while the tablet is asleep, because other developers report that doing so blanks the sleep screen to white. A switch that falls due then waits for the next wake.

The same broadcast with type 17 sets the power-off picture. BooxUltimatum renders the chosen face in portrait, without the battery and put-down time that would be out of date by the next power-on, and sends it on request. Boox saves its own copy (logcat, Android's system log: SaveShutdownImageAction: Save shutdown image succeed, for both the normal and the charging variant), so the picture changes only when set again. Restore sends Boox's /system/media/shutdown-default.png.

Read fresh at every sleep, never while asleep

A file directly in /sdcard/Pictures/ is used in place and decoded afresh each time the tablet goes to sleep, so overwriting it between sleeps changes the next sleep screen. A file anywhere else is copied once, and later overwrites are ignored. Boox drops files above 10 MB. Once asleep, nothing is read again, and Boox itself only redraws its own clock overlay, every 5 minutes. So by default BooxUltimatum keeps the face current only while the tablet is awake:

  1. While awakeA non-wakeup inexact alarm (ELAPSED_REALTIME), which Android may delay and which never wakes the tablet, fires every 1, 5, 15 or 30 minutes. Battery, time, date and screen-on broadcasts, which the system sends anyway, also trigger a refresh. Triggers within 2 s count as one.
  2. Each refreshBooxUltimatum fingerprints the face's content and settings. If the fingerprint is unchanged, it skips the render, the encode and the write. It also renders the other orientation and keeps it ready.
  3. Going to sleepONYX_SYSTEM_GOING_TO_SLEEP arrives tens of milliseconds before Boox decodes the picture. If the picture doesn't match the rotation, BooxUltimatum writes the ready one at once.
  4. AsleepNothing is read. The alarm never fires, and a missed one is delivered on waking. Live updates, described next, change this.

Live updates while asleep

Live updates are optional, off by default, and work only in Sleep image mode. The sleep screen, com.onyx/.common.dream.OnyxDaydreamService, is fixed by config_dozeComponent, a firmware setting that no app can change. It never re-reads the picture, but it registers an exported receiver for onyx_dream_refresh. Any app can send that broadcast, and the dream then wakes the display for about 1.2 s (onyx.action.DISPLAY_CHANGED_STATE, state 2, then 3). Frames drawn while it dozes are held until then. The lock screen hides every app window except an accessibility overlay, so an accessibility service that reads nothing on screen holds the face.

  1. Going to sleep4 s after Onyx has drawn and dozed, the first live face goes up, covering the charging bar too.
  2. Every stepAn exact alarm that wakes the tablet (RTC_WAKEUP) fires on the round minute, at the step you choose: 1, 5, 10, 15, 30 or 60 minutes. Each time, BooxUltimatum renders the face, sends the refresh and shows the face once Onyx reports the display on. The tablet is awake for about 1.4 s, and a full repaint runs every sixth update.
  3. WakingThe overlay is removed at once, so the lock screen and PIN pad are never covered.

Boox's power manager (android.onyx.pm.OnyxAlarmHelper) clears wake-up alarms at sleep unless BooxUltimatum is on its full-access list, which it joins when its background use is changed to allowed. This was verified on battery on a Note Air6 C with firmware 4.3. An earlier whole-tablet measurement reported about 1% of battery per one to two hours of sleep. A longer measurement on 2026-10-04, over 32 hours on battery and using Android's own per-app accounting, billed the one-minute step about 1.6 mAh an hour, and the 5-minute step wakes the screen a fifth as often. So on battery nothing shorter than 5 minutes runs, and the 1-minute step runs only while charging.

Both orientations, prepared

Boox centre-crops the picture to the rotation it sleeps in: 1860 × 2480 in portrait, 2480 × 1860 at rotation 90 or 270. A face drawn only after a turn left a few seconds in which a sleep showed the old shape cropped. So every refresh also encodes the other orientation into noBackupFilesDir/sleep-cache. A rotation is seen through a display listener, Android's callback for screen changes, before the configuration reaches the process. BooxUltimatum then swaps that file in at once, with a fresh render 1.5 s later. Tested on a Note Air6 C by rotating and sleeping within 0.2 s in both directions: the picture was written 100 ms after Boox's going-to-sleep broadcast and 260 ms before the dream decoded it.

Boox's bar while charging

Boox draws a status bar (battery, “Press power button to wake up”) along the bottom of any sleep screen unless Screensaver › Bottom Status Bar is off, and always while the tablet charges. In com.onyx the check is isShowBottomStatusBar() || isBatteryCharging(), and it reads the real charger, so dumpsys battery unplug doesn't hide it. Faces don't reserve the strip. The Sleep page asks you to turn the bar off and says why it still shows while charging. Live updates cover it.

Over Transparent is T2, or T0 with one consent

Boox's Transparent style snapshots the screen and can lay a sticker PNG, a see-through picture, over it. Boox saves the sticker as Pictures/Sticker/sticker_<timestamp>.png. It reads the sticker from one stored path, at every sleep and never during one. It decodes the sticker at the screen's size in the rotation the tablet sleeps in, and keeps only a centred square 0.75 of the short side wide (1395 px). So BooxUltimatum draws the plates inside the band that survives either way, and one file is right both ways up.

The shell user can write that picture and BooxUltimatum can't on its own, so the mode uses Shizuku when it runs. Otherwise BooxUltimatum asks Android once for permission to write that one picture (MediaStore.createWriteRequest, Android's call for write access to a shared picture), after reading the album with the picture permission. Either way, BooxUltimatum backs up Boox's own sticker first and journals every sticker it touches. A newer sticker means you picked again in Boox: BooxUltimatum follows it and puts the old file back. No broadcast can switch Boox to the Transparent style, so that choice and the one-time pick stay yours.

Still to confirm on a Note Air6 C: a real sleep with each plate in both orientations, whether the write consent survives a reboot, and what happens when you pick another sticker in Boox while Over Transparent is on. Also unconfirmed are whether Android's picture library picks up an overwrite made with mode "wt" at the next sleep, the Boox clock zone behind the layout guide (the top 22 %), and the render and encode times per face at full size.

Instant ink

Experimental

Boox Notes gets its ink under the nib in about 10 ms because SurfaceFlinger, the Android service that puts every frame on the screen, draws the stroke itself. Its touchReader and touchConsumer threads read the pen's event node, the file the kernel exposes for the pen. They push small HANDWRITE partial updates to the e-paper driver (/dev/ebc, open only to root and SurfaceFlinger). Apps don't draw that ink. They only arm it, with private ISurfaceComposer transactions for the pen state, the region, the stroke and the repaint.

This is a documented Onyx feature. App developers get it through Onyx's pen SDK (onyxsdk-pen, TouchHelper), which turns it on inside the calling app's own view. Under the hood the SDK calls the firmware helper android.onyx.ViewUpdateHelper. First it lifts Android's hidden-API check, the block on calling undocumented functions, with double reflection. Two things are not in the SDK, and they are what Instant ink adds: arming the path for another app that doesn't include the SDK, and handing the stroke back to that app after the lift. On firmware 4.3 (Android 16) the SDK's route is also closed to third-party apps (both calls are denied as api=blocked). So BooxUltimatum tries the firmware helper first and otherwise sends the same SurfaceFlinger transactions itself.

Any process can arm that path for whichever app is in front. BooxUltimatum does it from its ordinary app uid. The Shizuku route in the code is only a fallback for firmware that refuses the direct one. The other app is untouched and still receives every pen event.

One stroke

  1. ReadyAs soon as Instant ink is on, a session is opened and paused at once. On firmware 4.3 a session opened as the pen arrives misses the stroke that follows, while a paused one resumes instantly, even at the touch.
  2. HoverOn the Note Air6 C the pen reports hover as BTN_TOOL_BRUSH, only about 45 ms before BTN_TOUCH on a quick stroke, and a quick first touch comes in the same batch. BooxUltimatum reads which app is in front then, from usage events. If you chose that app, the session resumes. As Onyx's SDK does at hover, ENABLE_POST with 0 holds the app's own frames back, so the first point of the stroke lands on a held screen.
  3. TouchSurfaceFlinger draws the stroke, and holds the app's frames by itself from the touch (its HandlePenTrigger) until they're let through. The app still gets every pen event. Letting its frames through mid-stroke ends the preview for the rest of the stroke, so the app's drawing always waits for the lift.
  4. Lift + pauseENABLE_POST with 1 lets the frames through once the pen has rested for a pause you choose (0.4 to 2 s), and the app's real stroke replaces the preview. Quick strokes share one preview, as in Boox Notes. The pen session stays open.
  5. Pen awayBooxUltimatum swaps at once and pauses the session, so nothing of BooxUltimatum's draws if the next app isn't one you chose. The eraser end pauses it too, and so does the screen turning off. Over Boox's own apps, which run sessions of their own, it never ends a session.

A tap with the pen often opens another app while the pen stays in range, so the app in front is read again a few times after a tap. Keeping one session open is the point. Closing it and repainting also removes the preview, but a session reopened at pen-down lost the start of the stroke, and one reopened at hover missed quick strokes. HANDWRITING_REPAINT, REPAINT_EVERY_THING, SAVE_PEN_ATTACHED_FB, the auto-sync switch and the screen-note pipe were all tried one call at a time on a stuck preview, and none of them removed it. ENABLE_POST did, even as a quick hold-and-release when nothing had held the frames.

The region lives in the panel's landscape frame

SurfaceFlinger reads the handwriting region in the display's own landscape frame, whatever the rotation. On a Note Air6 C, a portrait-shaped region of 1860 × 2480 gave no preview in the bottom quarter of a portrait screen, below y = 1860. So the region is always a square as large as the long side, 2480 × 2480, which covers the screen in every orientation.

The android.ui.ISurfaceComposer transactions the client uses, as found on firmware 4.3.
TransactionCodeUsed for
SET_PEN_STATE16711693Start, draw, pause or stop the session, with the pid of the process that owns it
SET_REGION_LIMIT16711694The square region, long side by long side
SET_STROKE_STYLE / WIDTH / COLOR16711688 / 87 / 86Sent in that order, after the pen state goes to start: choosing a style resets the width to that style's default, so a width sent first was lost. 4 px, black, fountain pen (style 1) by default.
ENABLE_POST16711692Hold app frames (0) and release them (1): the swap
GET_PEN_STATE1048643Probe the route, and read the session state
REPAINT_EVERYTHING16711700Only in release, when the client lets go, handing the display back to normal drawing

On the maintainer's Note Air6 C the pen's event node is /dev/input/event5 (onyx_emp_istaric_pen). Apps can read the node on this firmware but not its name, because SELinux closes /sys/class/input to apps. So the reader opens every readable node, takes the first that reports a pen tool and remembers it. The reader thread sleeps in poll() until the pen moves, so nothing wakes the tablet, and a 30-second watchdog makes sure app frames are never left held back. Knowing which app is in front needs usage access, a permission you allow on the tablet. Where the firmware's switch refuses, the Instant ink page shows the computer command (appops set app.booxultimatum GET_USAGE_STATS allow).

What isn't done yet

  • Checked with a real pen by the maintainer in Sketchbook on a Note Air6 C. Owners report it working on a Go 10.3 Lumi and a Note Air 2 Plus since 0.5, and on a NoteX3 Pro through the direct route. Before 0.5, Instant ink never worked on those tablets, because it needed usage access without asking for it and always listened to the maintainer's own pen device.
  • The preview is Boox's black pen, so a coloured brush or the eraser shows only once the app's own stroke takes over.
  • Pen strokes can't be simulated: input, the adb command that injects touches, goes through InputDispatcher, which SurfaceFlinger's pen reader doesn't read. Every test needs someone drawing.

A second route, EinkWise's per-app handwriting mode (noteConfig), was tried on Sketchbook and didn't engage. Its config was written back byte for byte, and it isn't shipped.

The battery log

A tool that measures drain must not cause any. The battery log has no foreground service, which is a task Android keeps running behind a visible notification, and no wake lock, which is a request that keeps the processor awake. It samples about every 30 minutes on AlarmManager.setInexactRepeating with ELAPSED_REALTIME, the non-wakeup variant. Android batches that alarm with other work and delivers it only when the tablet is already awake, so the log adds no wakeups at all.

The alarm is set only when it's absent. Re-scheduling an inexact repeating alarm restarts its countdown, which dumpsys alarm showed before and after opening the app. So scheduling on every open could have kept the log from ever sampling.

What a row holds

  • Light samples: battery level, charge counter in mAh, voltage, temperature, whether the tablet is plugged in, screen on, elapsed realtime and uptime, boot count, current, front light, Wi-Fi, Doze (Android's deep sleep) and Battery Saver. Between two samples, 1 − Δuptime/Δelapsed is the share of time the tablet spent suspended.
  • Transition rows: screen_on, screen_off, plug, unplug, level (a 1 % step on battery), doze_deep, doze_light and saver, from broadcasts the system sends anyway. Standby and use are split exactly.
  • Deep snapshots every 3 hours: Doze state, alarm wakeups by app and tag, wake locks, CPU and Wi-Fi by uid (the number Android gives each app), foreground time.
  • Opening BooxUltimatum adds a sample, at most one every 10 minutes.
  • Since 0.9 every row also holds the display's state (display), the app in front (top) and a note (note). There are also rows for a display that stayed on while the tablet was not in use, for 2 minutes (display_on) and for 10 minutes (display_stuck), for marks, for the steps of Switch off a display that stays on, and, since 0.10.1, for each wake that followed a refresh of the sleep screen while asleep (keepalive). A Handler writes them, with no wake lock and no alarm. When the layout grows, a new header line is appended and the reader follows it, so old files still read.

Android 15 and later send BOOT_COMPLETED to an app the first time it starts after a force stop, so the log once recorded 33 “boot” rows without a single reboot. It now compares Settings.Global.BOOT_COUNT and records those as unstop. Files are CSV and JSONL in Android/data/app.booxultimatum/files/logs, pruned after 60 days, and shared as one zip with a README that explains the columns.

What it found so far

FindingHow it was read
Standby drew 0 to 12 mA in the first two unplugged sleeps. Boox's own sleep turns Wi-Fi off within 0.5 s and suspends the processor within 30 s.batterystats history, two unplugged sleeps
Over 28 days, the usual standby draw is 15 mA, and 9 mA on the quietest nights, as long as the display goes to sleep.BooxUltimatum's battery log, the hours-weighted median of the sleeps
Four times, the display stayed on while the tablet slept and drew 300 to 360 mA. Each began exactly 90 minutes after the sleep screen last refreshed, after Android had restarted by itself.The battery log, batterystats history and the dropbox (docs/10-battery.md)
After Android restarts by itself, the processor stays awake through every sleep until the tablet is restarted: 10 to 46 mA asleep instead of about 7.Uptime against elapsed time in the battery log (docs/11-not-resting.md)
Screen-on use drew 430 to 640 mA (12 to 17 %/h), with the processor awake 93 % of the screen-on time.dumpsys batterystats since unplug
On firmware 4.3, TIME_TICK is a wakeup alarm, and sys.onyx.idledelay=2500 lets the processor sleep between page turns when nothing else keeps it up.dumpsys alarm, getprop
Doze, Android's deep sleep, starts disabled at every boot (config_enableAutoPowerModes=false). Turning it on changed little: no Doze transition was seen in two unplugged sleeps.aapt2 dump resources, dumpsys deviceidle
BOOXDrop (com.onyx.easytransfer) had used 8 min 27 s of CPU in 4.5 h of uptime, the most of any Onyx process.top, TIME+ column

Every finding above was read on the maintainer's Note Air6 C with firmware 4.3. No before-and-after battery runs are recorded yet, so BooxUltimatum shows no savings. For live updates while asleep, two measurements exist on that tablet: an earlier whole-tablet measurement of about 1% of battery per one to two hours, and about 1.6 mAh an hour for the one-minute step over 32 hours on battery (see the live updates above). For comparison only, eWritable measured about 2 %/h idle and 10 %/h writing on the same 4.3 firmware.

The tablet font

Boox Settings › Display › Font Style changes the tablet font without root, through a broadcast that SystemUI handles. BooxUltimatum sends the same one:

am broadcast -a onyx.action.font.replace.system \
  --ei font_lang 0 \
  --es args_path '/storage/emulated/0/fonts/<family>.ttf'

SystemUI writes the persist.sys.font.* properties and reloads the font in every app, with no reboot. onyx.action.font.reset.default returns to the Boox default. The interface was learned by decompiling ChangeSystemFontAction and BroadcastHelper in Boox's own settings package. It was then confirmed from the shell and from the app by reading getprop before and after.

  1. The font file must sit in shared storage where SystemUI can read it. With Shizuku it is copied to /sdcard/fonts (the folder NeoReader also reads). Without Shizuku, BooxUltimatum writes its own copy to Documents/BooxUltimatum/ through MediaStore, Android's shared media library, and sends the broadcast itself, so the tablet-wide font needs no Shizuku since 0.4.
  2. The path in use before the first change is journaled, once.
  3. The broadcast is sent, then the property is read back for up to five seconds. BooxUltimatum reports success only once the tablet has actually switched.
  4. Restore previous font sends the journaled path again, or the reset broadcast when it was the Boox default.

One surprise: the tablet font on the maintainer's Note Air6 C was a variable Manrope, a single file that holds many weights. Android hands apps its default instance, which is ExtraLight, so everything drawn in the tablet font looked thin. BooxUltimatum home now loads the tablet font with explicit wght instances, one step heavier by default, and Use on the whole tablet comes with a weight choice.

Reversible tweaks and the journal

A tweak is a small class with an id, a group, a tier, a risk, a way to read its state, an apply and a revert. The app shows a revert as Undo. Apply and revert never throw an exception: a failure comes back as a readable message, and both outcomes are written to the journal.

  • The original is kept once. Before changing anything, a tweak stores the previous values only if none are stored yet, so applying twice never loses what the tablet had. The write finishes before the change is made, because some changes (fonts, overlays) restart the process straight after.
  • Undo only undoes what BooxUltimatum did. A tweak that restores a recorded value offers Undo only when BooxUltimatum made the change. If the tablet already had that value, undoing would invent a state the tablet never had.
  • Preset, which the app shows as “Already set on this tablet”, means the firmware already ships the tweak's value. BooxUltimatum shows it as on and offers no Undo.
  • The journal lives in BooxUltimatum's private preferences, keeps the last 200 entries, and never leaves the tablet.

Round trip below means applied on the tablet, the state re-read as on, undone, and the original confirmed.

The 19 tweaks as verified on the Note Air6 C, firmware 4.3.
TweakTierMechanismStatus
apps.backgroundT2RUN_ANY_IN_BACKGROUND allow for user apps Boox restrictedRound trip 2026-09-25
doze.enableT2dumpsys deviceidle enableRound trip 2026-09-25; resets on reboot
doze.boox_allowlistT2Non-essential Boox apps off the Doze allowlistRound trip still to record
bg.boox_restrictT2RUN_ANY_IN_BACKGROUND ignore for optional Boox appsRound trip 2026-09-25
power.saverT2cmd power set-mode 1Applies only once unplugged
power.adaptiveT1App Standby and Adaptive Battery onPreset
power.autosyncT0Master auto-sync offRound trip still to record
power.timeoutT2screen_off_timeout = 2 minutesRound trip 2026-09-25
power.stay_awakeT1stay_on_while_plugged_in = 0Preset
radio.wifi_scanT1wifi_scan_always_enabled = 0Preset
radio.ble_scanT1ble_scan_always_enabled = 0Round trip 2026-09-25
radio.wifi_wakeupT1wifi_wakeup_enabled = 0Round trip 2026-09-25
radio.locationT2Location offPreset
ui.serif_fontT2Noto Serif font overlayRound trip 2026-09-26
ui.animationsT1Animation scales = 0Preset
privacy.dnsT1Private DNS to dns.adguard-dns.comRound trip 2026-09-25
privacy.otaT2pm disable-user on the OTA (updater) serviceRound trip still to record
privacy.storeT2pm disable-user on the two Boox storesRound trip 2026-09-25
privacy.factoryT2pm disable-user on the factory test appPreset

Outside the list, and journaled the same way, are status bar icons (icon_blacklist), the battery percentage, the default home app, the tablet font, the sleep screen, and fonts copied for NeoReader. Package tweaks use pm disable-user, which is reversible. Nothing is ever removed from the system partitions.

Nib, the drawing app

Nib is the suite's drawing app. It has its own install and its own updates through BooxUltimatum's Suite page, and it works without BooxUltimatum. It draws the way Boox Notes writes. The display paints each stroke under the nib at once through the same pen path as Instant ink, and Nib's own rendering takes its place the moment you lift. Nib has pens, pencils, markers, brushes and textured charcoal, unlimited layers, a lasso, a page that turns, and exports. Tried with a real pen on the maintainer's Note Air6 C, the preview feels clearly faster than in other drawing apps.

Since Nib 0.3 (2026-10-07), Nib writes the way Boox's own apps do: one display hold per writing session instead of one per stroke, so quick strokes follow each other without a pause. Its pens are matched to Boox's own pressure, tilt and nib behaviour. The details live in the design doc.

The app's own language

New

Boox tablets are sold with Chinese firmware all over the world, so the language a reader speaks is often not the one their tablet is set to. A translation that can only be reached by changing the tablet's language therefore reaches almost nobody, so the app's language is a setting of its own, kept for each app: BooxUltimatum and Nib are separate programs, and each remembers what you chose.

Three things make the choice. The tablet's language is the default, so nothing has to be chosen for the common case. Each app has a Language row: Device › Language in BooxUltimatum, About › Language in Nib. On Android 13 and later the app's languages also appear in Android's own App languages screen, and the app and that screen write to the same place, so they never disagree. On Android 11 and 12 the app keeps the choice itself and applies it to the activity's base context.

The suite reads in Simplified Chinese and Vietnamese. A language is a folder beside the English one, with the same file names and the same keys, and a check runs on every push to hold a translation to that: a string that is missing, a value that changed, a plural form the language does not have, or a language offered without words behind it. A new language is a folder and a line.

The bundled face is a Latin one: it has every Vietnamese letter, Đ included, and no Chinese character at all, so Chinese text falls back to the tablet's own system font and is drawn in it.

Clean-room interoperability

BooxUltimatum contains no Onyx or Boox code, SDKs or assets. It learned the Boox interfaces it uses from Onyx's public SDK documentation, by observing the tablet, and by reading how Boox's own apps call the firmware:

  • the sleep-picture and tablet-font broadcasts, which aren't publicly documented;
  • the SurfaceFlinger handwriting and post transactions behind Instant ink, which Onyx's pen SDK documents for an app's own views;
  • the EinkWise configuration it reads.

Only the facts are used. They are called through small clients written from scratch in core/sleep/, core/SystemFont.kt and core/ink/. Onyx's SDK itself, onyxsdk-pen and onyxsdk-device, is published as obfuscated binaries without source, so it isn't bundled. These interfaces aren't a stable public API, so a firmware update can change them without notice. When something stops working, BooxUltimatum says so rather than guessing.

The dependencies are AndroidX and Jetpack Compose and the Shizuku API, all Apache-2.0. The one bundled asset is Archivo, under the SIL Open Font License. BooxUltimatum goes online for three things only: weather from Open-Meteo for the city you type, Google Fonts when you open the fonts browser, and GitHub's release list when it checks for updates. There are no accounts, analytics, ads or trackers.

Help and history