CodeAssist

A lightweight, on-device IDE that edits and builds Android & Java projects — no laptop, no Gradle daemon.

CodeAssist is an extensible IDE framework that runs entirely on device (Android/ART) and edits and builds Android/Java projects without hosting Gradle. A full Gradle runtime is too heavy for a phone, so CodeAssist models projects itself, mimics Gradle's incremental task engine without the Gradle daemon, and drives the Android toolchain (aapt2, D8/R8, apksigner) directly.

It is designed to be lightweight:

• No Gradle daemon. Projects are a declarative model compiled into an incremental task DAG with fingerprint up-to-date checks and a persistent cache — Gradle's good ideas, none of its weight.
• Flat-memory indexing. Library/SDK symbol indices are disk-backed immutable segments queried in place through a bounded block cache, so heap stays flat regardless of index size.
• Fast, incremental everything. Editing one file re-runs only the affected build tasks; completion and analysis reuse a cached compilation environment instead of rebuilding it per keystroke.
• On-device toolchain. Pure-Java tools (Eclipse JDT/ecj, D8/R8, apksigner) run in process; native aapt2 is invoked as a subprocess.

It ships with a Compose Multiplatform UI and both desktop and Android launchers.

• ☕ Java code intelligence — error-tolerant parsing, ranked completion, diagnostics, and quick-fixes powered by Eclipse JDT.
• 🟪 Kotlin completion (beta) — full Kotlin code completion on device, tuned to the same ranked experience as Java. How it works →
• 🧩 Block editing — project any Java file into a Scratch-style block tree and edit it there; changes write back to the source byte-for-byte. How it works →
• 📐 Android XML assist — tag, attribute, and resource completion for layouts/manifests with live validation.
• 📦 Real APK builds on device — resolve, compile, dex, package, sign, and install — no laptop.
• 🌱 Git, on device — stage, commit, branch, merge, stash, and push without a laptop; sign in to GitHub to clone private repositories and open pull requests. How it works →
• 🔌 Extensible everywhere — module types, build systems, language backends, analyzers, quick-fixes, and more all plug in through extension points.

A real IDE, on your phone. Write, navigate, and build end to end.	Compose @Preview, live. See your UI next to the code as you type.	Completion that keeps up. Ranked Kotlin and Java suggestions, even on half-written code.
Build real APKs, on device. Resolve, compile, dex, package, sign, install.	An AI agent, built in. Ask for a change; it edits, builds, and shows the diff.

_{On tablets and foldables the file tree, editor, and preview sit side by side.}

Any Java file can be projected into interlocking, typed blocks — and edited there. The block tree is a live projection of the same DOM the code editor uses, so the two views never drift; a block edit compiles to the smallest possible source edit, leaving every untouched line and comment intact.

   

Typed value sockets (Scratch-style shapes for boolean/number/string/type), inline completion inside sockets, palette search, and drag-and-drop all map back to the same surgical projection pipeline. Read how the projection and edit round-trip work →

CodeAssist tracks completion quality, editor latency, indexing, and build performance against committed baselines (a regressionTest suite that fails CI on a quality regression). The numbers below regenerate on each release.

What the metrics mean

• recall — fraction of cases where the expected completion appears in the list at all.
• top-1 / top-5 — fraction where the expected item is ranked first / within the first five.
• MRR (mean reciprocal rank) — average of 1 / rank of the expected item; 1.0 means it is always first.
• latency — wall-clock time to compute completion at a keystroke (recorded on the maintainer's machine, so treat as indicative; quality metrics are deterministic across machines).
• incremental tasks — how many build tasks re-run after a single-file edit; fewer means more precise incrementality.

2099 tests passing across 375 suites · 0 failing · 2 skipped (framework / CI_CORE_ONLY).

The badges and the numbers in this section are regenerated automatically on each release (see .github/workflows/update-readme.yml).

Sixty modules, grouped on disk by the layer they belong to:

platform/      no domain knowledge; depended on by all
lang/          reading source: the language SPI, indexes, analysis, per-language backends
build-system/  the incremental task engine and the JVM build pipelines over it
run/           executing project code on device: source interpreter, bytecode VM, AWT/Swing
android/       Android as a target: facets, variants, SDK metadata, layout preview, ART shims
services/      cross-cutting api/impl pairs: deps, version control, store, analytics, agent
plugins/       the SPI a third-party plugin compiles against, and the host that resolves it
app/           the IDE itself: the Compose UI and the desktop/Android/headless-CLI shells
tools/         test-only harnesses

Gradle paths stay flat, so a module's directory never has to be spelled out to build it: the Kotlin editor backend is :lang-kotlin even though it lives at lang/lang-kotlin. settings.gradle.kts maps the two, and is the only place that mapping exists.

Dependencies point downward only (acyclic). Platform modules carry no domain knowledge; domain behavior is contributed through extension points.

platform-core            no domain knowledge; depended on by all
  └─ vfs-api
       └─ project-model-api
            ├─ build-api
            └─ language-api
deps-api / index-api / analysis-api / block-api  → the layers above
ide-ui (Compose UI) ← ide-core (engine→UI bridge) ← ide-desktop, ide-android

The full table — every module, its packages, and its responsibility — is in docs/modules.md.

The build uses the Gradle wrapper and a JDK 17+ (developed against the JetBrains Runtime).

# Core framework only (pure JVM; no Android SDK or Compose shells needed)
CI_CORE_ONLY=true ./gradlew check

# Full build, including the Compose UI and Android launcher (requires the Android SDK)
./gradlew build

# Run the desktop IDE
./gradlew :ide-desktop:run

# Assemble the Android launcher
./gradlew :ide-android:assembleDebug

The regression suite (completion quality, latency, allocation, and build-at-scale) is opt-in and runs via the regressionTest tasks against committed JSON baselines.

• IDs are @JvmInline value class wrappers — no stringly-typed APIs.
• Open-ended classifications (NodeKind, BuildSystemId, LanguageId) are string-backed value classes so plugins can extend them; closed sets (DependencyScope, SymbolKind) are enums.
• Long-running entry points are suspend and run under the read/write-lock discipline; model and DOM access happens inside read/write actions.
• Mutation is transactional: stage on a *Transaction/Modifiable*, then commit().
• Editor features target the neutral DomNode/Symbol/Scope, never a backend's native types.

CodeAssist is free software licensed under the GNU General Public License v3.0 or later (GPL-3.0-or-later). See LICENSE.

The plugin SPI is the one exception. The modules a plugin author compiles against (plugin-api, plugin-ui-api, platform-core, and the feature SPIs vfs-api, project-model-api, language-api, index-api, analysis-api, build-api), published under io.github.tyron12233, add the Classpath exception (GPL-3.0-or-later WITH Classpath-exception-2.0, see LICENSE-EXCEPTION) so that a plugin compiled against them may be released under any license, proprietary included.

• Google Play — testing track (signed via Play App Signing).
• F-Droid / IzzyOnDroid — built from this repo, signed with the project's own key. See docs/fdroid-izzyondroid.md. (The IzzyOnDroid and Play builds have different signatures and cannot update across stores.)

Join the CodeAssist Discord to chat, get help, report bugs, and share what you build.