# CodeAssist: an on-device Android IDE that builds APKs without Gradle

> CodeAssist is an experimental Kotlin IDE that runs on Android and builds Android and Java projects on the phone itself. This review covers how its task engine works, what installing it involves, and where it stops being the right tool.

**tyron12233/CodeAssist** — Experimental IDE for building Android applicatons on Android. CodeAssist A lightweight, on-device IDE that edits *and builds* Android & Java projects, no laptop, no Gradle daemon.** What is CodeAssist?

- Repository: https://github.com/tyron12233/CodeAssist
- Stars: 1,919 · Forks: 408
- Language: Kotlin
- License: GPL-3.0
- Published: 2026-08-08 · Updated: 2026-08-18 · Language: en
- Canonical page: https://hysenlabs.com/projects/tyron12233-codeassist

## The problem CodeAssist is aimed at

Android development assumes a workstation. Gradle starts a daemon, the Android Gradle Plugin wires up tasks, and the resulting process wants more memory and disk than a phone will give it. The README states the project's premise directly: a full Gradle runtime is too heavy for a phone. CodeAssist is the answer to that constraint, and it is aimed at people who want to write and build Android or Java code on the device they already carry.

The intended user is not a team replacing Android Studio. It is a single developer on a phone or tablet who wants completion, diagnostics, a real build, and an installable APK without a second machine in the loop. The project ships both Android and desktop launchers with a Compose Multiplatform UI, so the same engine can run on a laptop, but the Android launcher is the point of the exercise.

## How the build engine avoids the Gradle daemon

CodeAssist does not embed Gradle. It models projects itself. According to the README, projects are a declarative model compiled into an incremental task DAG with fingerprint up-to-date checks and a persistent cache. That is the mechanism: instead of running Gradle's task graph, CodeAssist builds its own and decides what is stale by comparing fingerprints against a cache that survives between sessions.

Below that model sit the actual Android tools. Pure-Java components (Eclipse JDT/ecj, D8/R8, apksigner) run in process, while native aapt2 is invoked as a subprocess. The documented pipeline is resolve, compile, dex, package, sign, install. That is a conventional Android build with the orchestration layer swapped out.

The indexing design follows the same memory-first logic. Library and SDK symbol indices are disk-backed immutable segments queried in place through a bounded block cache, so heap usage stays flat as the index grows. Completion and analysis reuse a cached compilation environment rather than rebuilding it on every keystroke. The README's own benchmark table reports Java completion latency of 4.3 ms for member access and 2.8 ms for a type reference, with the caveat that latency was recorded on the maintainer's machine and should be treated as indicative. Quality metrics, the README says, are deterministic across machines.

The module layout is worth noting because it constrains what the project can become. Dependencies point downward only: platform-core, then vfs-api, project-model-api, build-api and language-api, with ide-ui and ide-core above them. Platform modules carry no domain knowledge, and behavior is contributed through extension points. This is a framework decision, and it is why the README describes CodeAssist as an extensible IDE framework rather than an app.

## Installing CodeAssist and opening a first project

The README does not give command-line install steps for the IDE itself. It points to the releases page for builds, and the repository contains an Android launcher, a desktop launcher, and Fastlane metadata under fastlane/, which is the usual shape for an app distributed as an APK. So the practical route is to take the release artifact from the releases page rather than to build from source.

If you do want to build the IDE from source, the repository is a Gradle project with a wrapper at the root. The README's Build section is truncated in the available text, so treat the following as the repository's entry point rather than a documented recipe:

```bash
./gradlew build
```

The interesting part of the repository for a new user is not the IDE build, it is the plugin sample. samples/hello-plugin/ exists to demonstrate the extension points, and the module layout shows why: module types, build systems, language backends, analyzers and quick-fixes all plug in through extension points, and docs/extension-points.md documents the language-backend SPI. If you are evaluating CodeAssist as a framework rather than as an editor, that sample is where to start reading.

Inside the app, the workflow the README describes is: open or create an Android/Java project, edit with JDT-backed completion and diagnostics, then run the build pipeline (resolve, compile, dex, package, sign, install). Signing is handled by apksigner in process, and the repository ships a keystore.properties.example at the root, which indicates where signing configuration is expected to live. The README does not document the exact keys, so read that example file before setting up signing.

## What the Kotlin support actually is

The headline feature list leads with Java code intelligence and marks Kotlin completion as beta. That ordering is honest and worth taking at face value. Java gets error-tolerant parsing, ranked completion, diagnostics and quick-fixes from Eclipse JDT, a mature parser with a long history in Eclipse tooling. Kotlin gets completion, described as full and on device, tuned to match the Java experience, with a link to docs/kotlin-completion.md.

Completion is not the same as a full language service. The README does not claim Kotlin diagnostics, Kotlin quick-fixes, or Kotlin refactoring on the level of the Java side. If your project is Kotlin-heavy, the beta label is doing real work: you should expect the Java path to be the more complete one, and you should read docs/kotlin-completion.md to see what is implemented before you judge the editor on a Kotlin file.

The block editor is the other distinctive piece. Any Java file can be projected into a typed block tree, Scratch-style, and edited there. The README states that the block tree is a live projection of the same DOM the code editor uses, and that a block edit compiles to the smallest possible source edit, leaving untouched lines and comments intact. That claim is testable in normal use: edit a block, switch to the code view, and check whether the diff is as small as advertised. Note the Java-only scope. Kotlin files do not get the block view.

## Where CodeAssist is the wrong tool

The project model is the main boundary. CodeAssist mimics Gradle's incremental engine rather than running Gradle, so anything that depends on Gradle's actual execution semantics is out of scope. Custom Gradle plugins, annotation processors wired through the Android Gradle Plugin, build variants defined in a way the model does not understand, and complex multi-module dependency graphs are all places where a reimplementation can diverge from what the desktop build produces. The README points to docs/build-system.md for Gradle compatibility, and that document, not the feature list, is what decides whether your specific project builds.

Resource-heavy projects are another risk. The pipeline uses native aapt2 as a subprocess, and the README does not describe how large resource sets, multiple densities, or incremental resource merging behave on a constrained device. The benchmark table covers completion quality, index query speed and latency. It does not report end-to-end build times for a real application, so there is no published number to reason about for build duration.

The third limitation is the platform itself. This is an IDE running on ART with a Compose UI, and the README's own latency figures are measured on the maintainer's machine. On a mid-range phone, keyboard-driven completion at that speed is plausible but unverified. If your work depends on a fast edit-build-run loop with a debugger, logcat integration and profiling, CodeAssist does not claim to provide that loop.

## How it differs from Android Studio and from AIDE

Android Studio is the reference point, and the difference is architectural rather than cosmetic. Android Studio delegates the build to Gradle and the Android Gradle Plugin, which means your build behaves exactly as it will in CI. CodeAssist replaces that layer with its own declarative project model and task DAG. You gain a build that fits on a phone. You give up the guarantee that your local build and your CI build are the same build.

AIDE is the closer comparison, since it is also an on-device Android IDE. The difference visible here is the extension model. CodeAssist exposes module types, build systems, language backends, analyzers and quick-fixes as extension points, with a sample plugin under samples/hello-plugin/ and a language-backend SPI documented in docs/extension-points.md. That makes it a framework you can extend, not just an editor you use. Whether that matters depends on whether you want to add a language backend or a custom analyzer; most people building an app on a phone do not.

There is also a distinction worth making for anyone arriving from search results. CodeAssist here is the tyron12233/CodeAssist project, an open source IDE under GPL-3.0. It is unrelated to Google's Gemini Code Assist or Oracle's Code Assist, despite sharing a name, and it is not an AI coding assistant. The README describes parsing, indexing, completion and builds. There is no model, no completion server and no AI feature in what the repository documents.

## Maintenance, licence and the cost of upgrading

The repository is not archived, and the last push was on 2026-08-26, the same date as the v3.9.9 release. Releases arrive frequently: v3.9.7 on 2026-08-19, v3.9.8 on 2026-08-22, v3.9.9 on 2026-08-26. That cadence suggests a project under active work, and the README explains part of why: the benchmark table and the test counts are regenerated automatically on each release through .github/workflows/update-readme.yml. The README reports 3217 tests passing across 499 suites, with 2 skipped for framework or CI_CORE_ONLY reasons, and mentions a regressionTest suite that fails CI on a quality regression.

That automation has a cost for anyone tracking the project: the README changes on every release, so the numbers you read today are not the numbers in the version you pinned. If you depend on a specific release, read the README at that tag rather than on main.

The licence is GPL-3.0, and the repository also carries a LICENSE-EXCEPTION file alongside it. Two licence files mean the terms are not simply GPL-3.0 for every component, and the exception is the thing to read. If you plan to ship a product that incorporates CodeAssist code, the exception file and its scope are what a lawyer needs to see. Nothing here is legal advice, and the repository does not spell out the exception's intent in the README.

Upgrade cost is tied to the extension points. If you only use the IDE, upgrading is taking a new release. If you have written a plugin against the language-backend SPI or another extension point, a minor release can move those interfaces. The README documents the SPI but does not promise stability across versions.

## Conclusion

Adopt CodeAssist if you write Java or Android code on a phone or tablet and want to build and sign an APK without a laptop, and if you accept a beta Kotlin backend and a project model that is not Gradle. Do not adopt it as a replacement for a desktop Android Studio workflow on a large multi-module app, and do not expect Gradle plugin compatibility. Before committing, check the build-system documentation for how your project's dependencies resolve, confirm your Gradle files parse, and verify that the Android SDK components your project needs are handled by the on-device toolchain.

## FAQ

### What is CodeAssist?

CodeAssist is an extensible IDE framework that runs entirely on device and edits and builds Android and Java projects without hosting Gradle. It models projects itself and drives aapt2, D8/R8 and apksigner directly, with a Compose Multiplatform UI and both desktop and Android launchers.

### How do I install CodeAssist on Android?

The README does not give command-line install steps for the IDE; it points to the releases page, and the repository contains an Android launcher and Fastlane metadata under fastlane/, which is the usual shape for an app distributed as an APK. Take the release artifact from the releases page rather than building from source.

### Is CodeAssist the same as Gemini Code Assist or Oracle Code Assist?

No. CodeAssist here is the tyron12233/CodeAssist project, an open source IDE under GPL-3.0 for editing and building Android and Java projects on device. It is unrelated to Google's Gemini Code Assist or Oracle's Code Assist, and the README describes no AI feature.

### Does CodeAssist use Gradle to build APKs?

No. The README states that a full Gradle runtime is too heavy for a phone, so CodeAssist models projects itself and compiles them into an incremental task DAG with fingerprint up-to-date checks and a persistent cache. The pipeline is resolve, compile, dex, package, sign and install, using Eclipse JDT/ecj, D8/R8 and apksigner in process and native aapt2 as a subprocess.

### Is Kotlin support in CodeAssist complete?

No. The README lists Kotlin completion as beta, offering full Kotlin code completion on device tuned to the same ranked experience as Java, while Java gets error-tolerant parsing, diagnostics and quick-fixes from Eclipse JDT. The README does not claim Kotlin diagnostics or quick-fixes at the Java level.

### What licence does CodeAssist use?

The repository is licensed GPL-3.0, and it also carries a LICENSE-EXCEPTION file alongside the LICENSE. Two licence files mean the terms are not simply GPL-3.0 for every component, so read the exception file for its scope.

## Sources

- [Official README](https://github.com/tyron12233/CodeAssist#readme)
- [Project repository](https://github.com/tyron12233/CodeAssist)
- [Release notes](https://github.com/tyron12233/CodeAssist/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/tyron12233-codeassist