DockMobile

Molecular docking on Android. DockMobile runs the UCSF DOCK 3.8 engine natively on a phone (arm64), with a touch GUI for importing a docking job, running it across multiple CPU cores, browsing scored results, and inspecting poses in an interactive 3D viewer with protein–ligand interaction analysis.

  

On the DOCK engine. DockMobile runs UCSF DOCK 3 (BSD-3-Clause), from docking-org/dock3. The DOCK source is not bundled here — the build fetches it automatically, so a clone builds from source out of the box (see Building). Please cite the DOCK references.

---

Features

• Import a docking job via the Android file picker
  • grid/parameter files (dockfiles), a receptor .pdb, and ligands
  • ligands as .db2 / .db2.gz, or nested .tar.gz tranches (e.g. ZINC build3d) — automatically unpacked, at any nesting depth
• In-app INDOCK editor — tune any DOCK parameter; grid paths and the DOCK version line are managed automatically at run time
• Multi-core docking — DOCK 3.8 is single-threaded, so the ligand list is split across N parallel dock processes; a slider caps N (default: half the cores) to balance speed against heat/battery
• Scored results table — per-ligand energy components (electrostatic, vdW, polar desolvation, total), sorted best-first; survives app restarts
• 3D pose viewer (OpenGL ES)
  • ball-and-stick ligand + receptor, CPK colours, pinch-zoom / drag-rotate
  • binding-pocket matching spheres; cycle poses by score
  • non-covalent interactions, each toggleable and geometrically filtered:
    • H-bonds — donor/acceptor chemistry with an explicit D–H···A angle (uses the ligand's hydrogens; drops acceptor–acceptor false positives)
    • salt bridges — charged residue ↔ oppositely-charged ligand group
    • π-stacking — aromatic ring ↔ ring (parallel / T-shaped)
    • π-cation — aromatic ring ↔ cation, over the ring face
  • interacting-residues list (only residues actually forming an interaction) or per-pose score breakdown

How it works

The Android NDK ships no Fortran compiler, so DockMobile cross-compiles DOCK with an aarch64 musl gfortran toolchain into a fully static, position-independent binary, ships it inside the APK as libdock.so, and executes it from the app's nativeLibraryDir. musl (not glibc) is required — a static glibc binary is killed by Android's seccomp filter at startup. See README-ANDROID.md for the full build internals.

Getting the APK

Easiest: download the latest release APK and install it on an arm64 device (Android 8+). Enable "install from unknown sources" when prompted, then tap Load example → Run Docking → View 3D.

Alternatively, every push builds a debug APK in GitHub Actions — open the latest green run under Actions → Build DOCK Android APK and download the DockMobile-debug-apk artifact.

Building

build-dock.sh fetches the DOCK source automatically from docking-org/dock3 (BSD-3-Clause), so a clone builds from source out of the box. You only need the aarch64 musl gfortran toolchain (e.g. from https://musl.cc) on PATH.

# aarch64-linux-musl-gfortran / -gcc on PATH, then:
native/build-dock.sh                                  # clones dock3, -> native/out/libdock.so
mkdir -p android/app/src/main/jniLibs/arm64-v8a
cp native/out/libdock.so android/app/src/main/jniLibs/arm64-v8a/
native/stage-assets.sh                                # bundles example/ into assets
cd android && ./gradlew assembleDebug

Overrides: DOCK_SRC=/path/to/dock3/src to use a local tree, or DOCK_REPO / DOCK_REF to pin a different source / revision.

Example data

example/ contains a small, self-contained docking job so you can try the app end-to-end:

• example/dockfiles/ — receptor grids + INDOCK
• example/db2/ — 8 ZINC ligands (.db2)
• example/receptor.pdb — a receptor structure for the viewer

Tap Load example → Run Docking to dock the 8 ligands, then View 3D. (The bundled receptor.pdb is in the crystal frame rather than the docking frame, so for that example the viewer shows the pocket spheres; import a receptor aligned to your grids to see the full interaction overlays.)

Licensing & attribution

• UCSF DOCK — the docking engine (© The Regents of the University of California) is BSD-3-Clause licensed and lives at docking-org/dock3. It is fetched at build time, not bundled here; its license is reproduced in NOTICES.md. Please cite the DOCK references.
• DockMobile app code (android/, native/) — released under the MIT License (see LICENSE).
• Example ligands — from the ZINC database (https://zinc.docking.org).

This is an independent project and is not affiliated with or endorsed by UCSF or the Shoichet/Irwin labs.

References

DOCK and the methods it implements:

1. Kuntz ID, Blaney JM, Oatley SJ, Langridge R, Ferrin TE. A geometric approach to macromolecule–ligand interactions. J Mol Biol 161(2):269–288 (1982).
2. Coleman RG, Carchia M, Sterling T, Irwin JJ, Shoichet BK. Ligand pose and orientational sampling in molecular docking. PLoS ONE 8(10):e75992 (2013).
3. Mysinger MM, Shoichet BK. Rapid context-dependent ligand desolvation in molecular docking. J Chem Inf Model 50(9):1561–1573 (2010).
4. Lyu J, Wang S, Balius TE, et al. Ultra-large library docking for discovering new chemotypes. Nature 566:224–229 (2019).
5. Irwin JJ, Shoichet BK. ZINC — a free database of commercially available compounds for virtual screening. J Chem Inf Model 45(1):177–182 (2005).

DOCK resources: https://dock.compbio.ucsf.edu · https://wiki.docking.org