SPGF (SPenGestureFix) is a local-first toolkit that restores programmable barrel-button gestures and a classic Air Command wheel on AOSP/LineageOS Notes, streams the Wacom digitizer to your PC, and drives it all from a portable Windows panel — no Samsung framework, no cloud, no telemetry.
Tap the pen to open Air Command
Flash AOSP or LineageOS on a Galaxy Note and Samsung's entire S Pen framework disappears. Air Command is gone, the barrel button goes dead, and one of the best Wacom digitizers ever shipped in a phone becomes just another input node nobody listens to.
SPGF talks to the kernel directly. A root shell reads raw events from sec_e-pen and the w1 presence switch, a state machine decodes clicks and hovers, and a foreground service drives overlays, actions and a normalized tablet stream. The Windows side mirrors the desktop and injects pen input back. No Samsung framework, no cloud, no telemetry.
All running locally on your devices, with nothing phoning home.
Single click, double click and long press each run an independent action — remap them anytime from the dashboard.
A configurable radial fan anchored lower-right like classic Note Air Command — up to seven slots in the classic skin, custom accent color, real color picker, open/close sounds, optional open-on-extraction.
The classic skin opens with the original 18-frame SpenCommand animation — bitmaps extracted from Samsung's own APK, replayed at the authentic 20 ms per frame (360 ms), and reversed on close. The modern arc springs open with an overshoot ease instead.
Fully offline notes with editing, search, copy, sharing, character counting, phone-number dialing and Maps lookup.
Annotate a screenshot with Screen Write, or crop a precise rectangle with Smart Select — both use coordinate-correct bitmap mapping.
Tunable pressure curves, monitor-matched orientation, smoothing, haptics, configurable pen button — plus a normalized TCP stream for the PC.
A single SPGF_WacomGUI.exe — no installer, no Python — with a live desktop mirror, adb detection, every streaming option, a filterable log and a photo card for each detected Note generation.
Jetpack Compose + Material 3, localized into English, Italian, Spanish, French, German, Portuguese, Dutch, Polish, Turkish, Russian, Ukrainian, Chinese, Japanese, Korean, Arabic, Hindi and Indonesian.
No accounts, no analytics, no network calls beyond your own LAN stream. Every byte is parsed on-device from your kernel's input stream.
Pick a gesture to see how a real mapping behaves. Every gesture is fully remappable in-app.
Phone Wacom drivers surface as Linux input devices, not reliable USB HID gadgets — so the service reads getevent -l through a root shell and owns every layer of the pipeline.
sec_e-pen carries absolute X/Y, pressure, hover, tip and barrel-button events. The separate w1 node reports physical S Pen insertion/removal through a device-specific switch code.
Each device gets its own EPenInputReader process running exec getevent. Stopping one reader never kills another process — a lesson learned the hard way.
PenGestureAnalyzer decodes single/double/long presses and hover transitions without ever blocking the digitizer stream.
SPenGestureService, an Android foreground service, routes results to overlays, broadcasts, mapped actions and the tablet capture pipeline. Overlay operations run only on the main thread.
Entering Wacom Mode pauses the normal reader and takes exclusive ownership of sec_e-pen, handing it back on exit. Two readers never compete for the same kernel stream — and a back event can't leave Wacom Mode accidentally.
Some ROMs never report the live switch, so presence also follows real activity: any pen event marks it extracted, and 5 seconds of silence marks it inserted again. This never gates the digitizer pipeline.
Devices are found via /proc/bus/input/devices, falling back to getevent -lp because some ROMs deny the proc file even to root. Initial slot state can come from driver nodes like epen_connection (OK/NG).
Compose pointer input stays local to a screen or the compact wheel window. The service never intercepts Android MotionEvent dispatch, so normal touch keeps working everywhere else.
Stream pressure-aware pen input straight into any desktop app on your PC — over ADB or Wi-Fi.
# optional newline-terminated metadata record:
#SPEN_TABLET 1 1920 1080 1 landscape
# then one record per frame:
X,Y,P,FLAGS| Bit | Meaning |
|---|---|
| 1 | Tip pressed |
| 2 | Right / barrel button |
| 4 | Eraser end |
| 8 | In-range (hover) |
| 16 | Middle button |
Axis mapping happens once on the phone; the Windows client only re-orients when its monitor aspect differs from the source metadata. Legacy clients can safely ignore the comment line.
Two ways in: the classic console scripts/SPGF_Wacom.py for terminal lovers, or the graphical SPGF_WacomGUI.exe with the live mirror below. Both drive the same engine — DPI-aware cursor injection over SendInput, or the TCP stream over Wi-Fi.
# discover devices and real axis limits
python scripts\SPGF_Wacom.py --list
# ADB mode over USB
python scripts\SPGF_Wacom.py --screen-w 1920 --screen-h 1080
# or just run the portable panel and press Start
SPGF_WacomGUI.exeOne portable exe that mirrors, configures and monitors the whole stream — built for people who never want to open a terminal.
Dashboard (mirror + controls), Phone (detection + photo database), Options (connection, quality, capture), Log and Guide — keyboard shortcuts included.
adb detection matches the model code to the generation — from the 2011 Note to the Note20 Ultra, Note Edge and Note7 included — and shows a real photo with author and licence credits.
No installer, no Python, no registry: one exe, settings in a JSON file next to it, fonts resolved at runtime, window clamped to the screen. Copy the folder to a USB stick and it just works.
FPS, JPEG quality, scale and frame counters update in real time; the mirror frame turns green when live and amber when paused, and the adaptive encoder degrades gracefully on weak Wi-Fi.
Assign any action to any side-button gesture or any wheel slot.
Launches a selected launcher application.
Opens or closes Air Command.
Captures into Pictures/SPenScreenshots.
Captures and annotates a screenshot.
Crops a selected rectangle from a screenshot.
Opens the offline note editor.
Searches launcher applications and opens one.
Starts a selected app in an experimental freeform window.
Toggles the available camera torch.
Runs the corresponding rooted svc command.
Sends the relevant rooted key event.
Runs an explicitly configured root command.
The milestones, newest first — full details in the README release notes.
Dark Windows titlebar, branded empty state and live border on the mirror, gallery selection ring, focus rings, status icons — and the project relicensed under MIT with a mandatory attribution clause. The app is now simply named SPGF.
The desktop panel was rewritten around five pages with a graphite theme, real photos for all eleven Note generations (fetched from Wikimedia Commons with credits), proportional hero renders, and a single-file portable exe — no Python needed on the target machine. Fixed a startup crash that kept the old panel in smoke-test mode forever.
Hub dashboard with section tiles, classic wheel up to seven slots with pixel-perfect bitmap discs, real HSV color picker, wheel sounds fixed for both styles — and the classic skin now opens with Samsung's original 18-frame SpenCommand animation (20 ms per frame, reversed on close).
Preview streaming gained a DXGI capture path with GDI fallback, input injection became app-gated, and runtime channels landed.
Screen mirroring from Windows to the phone via ADB while keeping the stylus working — you see on the Note exactly what the PC sends, at real quality.
Rooted barrel-button gestures, Air Command wheel, Quick Notes, screen tools and the first ADB-first Wacom emulator for Windows.
Real captures from the tested hardware and the desktop panel.
Everything you need before the first gesture fires.
su# From the repository root (Gradle 8.x or bundled .tools/gradle-8.13)
gradle :app:assembleDebug
# Install on a connected device
adb install -r app/build/outputs/apk/debug/app-debug.apkKotlin · AndroidX · Jetpack Compose · Material 3 — no NDK or JNI required.
The service notification reports whether the digitizer reader is active. If the kernel device is missing, the app stays usable as a configuration tool and reports the failure instead of blocking the UI.
Samsung Galaxy Note 3 SM-N9005
The only hardware validated on the connected rooted ROM used by this repository. Everything — presence switch, digitizer axes, Wacom Mode, the wheel — is tuned against this device.
ABS_X, ABS_Y, pressure, BTN_TOUCH and BTN_STYLUSEach target needs its own device-name, axis-range, switch-polarity, kernel-permission and orientation validation. An S Pen slot alone implies nothing.
# Inspect input devices without changing state
adb shell su -c "getevent -lp"
# Watch the app's own logs
adb logcat -s SPenGestureService EPenInputReader SPenDebugExpected capabilities include BTN_TOUCH, BTN_STYLUS and BTN_DIGI. The service accepts switch codes 001a, SW_001A and common pen-switch aliases; if the switch never fires, the 5-second activity fallback takes over.
No magic, no overpromises — here is exactly what this tool is and isn't.
getevent parsing has slightly more latency than a native binary reader.--orientation landscape-inverted.SPenGestureService.ktEPenInputReader.ktEventDeviceFinder.ktPenGestureAnalyzer.ktWheelOverlay.ktMainComposeScreen.kt et al.TabletInputCapture.ktTabletNetworkServer.ktscripts/SPGF_Wacom.pyscripts/SPGF_WacomGUI.pysite/docs/TRANSLATION.mdgradle :app:testDebugUnitTest
python scripts\test_i18n.py
python scripts\test_spen_mouse_emulator.pyCovers input parsing, presence decoding, the five-second idle rule, coordinate normalization and pressure curves. A connected phone is recommended for final acceptance testing because switch codes and polarity are kernel-specific.
Grab the latest APK and the portable Windows panel straight from GitHub Releases — or build them yourself from source.
Android
Rooted Android · AOSP/LineageOS-based ROM · Wacom digitizer required. Root via Magisk/SuperSU, overlay permission and notifications on Android 13+.
Windows · v2.1
Windows 10/11 · no installer, no Python. Settings live next to the exe; copy the file anywhere. USB detection uses adb if present, otherwise set the phone IP manually.
Added Preview mode — screen mirroring from Windows to the phone via ADB while keeping the stylus working — plus a new UI.
First public release. To use SPGF_Wacom.py you need ADB and Python installed on your Windows machine.
SPGF is free and open source under the MIT license. You can use, study, modify and redistribute it — including in your own fork or rebranded build — with one condition:
Any copy, fork, modification or redistribution — including renamed or rebranded versions — must credit the original project: SPenGestureFix (SPGF) by Clutsy — github.com/Clutsy/SPenGestureFix — in the source tree, in the app's About screen, in the documentation and on any download page.
The full wording lives in the LICENSE file. Independent open-source project — not affiliated with or endorsed by Samsung. S Pen and Galaxy Note are trademarks of Samsung Electronics.
Clone it, build it, flash your gestures back. Star the repo if it saves your Note from a drawer.