CodeAssist 3.13.0

CodeAssist 3.13.0

This release is about extending the IDE from inside it. Plugins can now contribute editor actions, UI, and build logic, and you can write one without leaving CodeAssist.

Editor actions

A new action layer sits at the caret, reachable from Alt-Enter, the editor's overflow menu, and the command palette. It ships with:

• Generate members: equals/hashCode, toString, constructors, getters and setters, and override stubs, with the generated code indented to match your file.
• Extract function and move to a new file.
• Kotlin intentions at the cursor, plus line-level actions.

Write a plugin in the IDE

• Create Project > Plugin scaffolds a working plugin: the packaged manifest, the marker activity, and an entry point, with the SPI already declared.
• The manifest is checked while you type: a malformed id, an API version this build cannot load, a minimum host version newer than your IDE, an entry point that names no class, a missing marker activity, and a capability the plugin has no facet to deliver are all flagged, with completion for the manifest's keys.
• A plugin you install is not run until you allow it. The IDE shows what the plugin says it does, the signing certificate of the installed package, and a plain statement that a plugin is not sandboxed, and asks first.
• An installed plugin can contribute Compose UI: tool windows, screens and overlays, alongside commands, settings pages and editor actions.
• Status dots on editor tabs are contributed the same way any plugin would.

Extend the build

Build logic is contributed rather than hard-coded, and the whole surface is now reachable from a plugin and documented in docs/custom-build-plugins.md: add a task to a build, generate source before compilation, add a Kotlin compiler plugin, put a row in the Run picker, or bring your own build system and project importer. samples/hello-plugin shows all of it working.

Along the way: a build plugin that fails is reported on the build console instead of silently skipped, generated code is compiled without the project having to declare a source root for it, and a plugin can read its own settings page while a build runs.

Fixes

• Apps using Firebase Crashlytics no longer crash at startup. Crashlytics needs a build-id resource that only its Gradle plugin writes, so this build system writes it, as it already does for Hilt and google-services.
• Dependencies declared with a version range now resolve. A ranged version went into the graph verbatim, so the fetch 404'd and the edge was dropped with its whole subtree and nothing reported. Adding the OneSignal SDK silently lost AppCompat, Firebase Messaging, Browser and CardView; that closure now resolves completely. Ranges resolve to the newest published version inside them, as Maven and Gradle do.
• An AAR shipping an empty classes.jar no longer puts an unopenable archive on the classpath.
• Kotlin: a library typealias resolves even though it has no class of its own.
• Console runs: arrays whose element type is one of your own classes.
• Simplified Chinese is complete, thanks to community contributions.

Faster builds

The JDK/ART compatibility jars and the Kotlin compiler are dexed as ordinary module artifacts now, which means they are dexed once and reused across builds, cleans and branches instead of being re-desugared against the whole runtime classpath every time.

CodeAssist 3.12.0

🚀 CodeAssist 3.12.0

The biggest release since 3.0: a completely new look, and a real Projects Store you can publish to.

A NEW LOOK

• CodeAssist moves onto Material 3 Expressive. Lime over warm neutrals is the new default accent, replacing the violet baseline the app has had since the rewrite. Violet, teal, orange and Material You are all still there in Settings > Appearance if you prefer one of them.
• Cards and tiles now rotate through the palette as you go down a list, and their corners vary by position, so two shelves on the same screen read apart from each other without a divider between them.
• A new rounded icon set (Material Symbols) throughout, filled or unfilled at the same size.
• Home, Learn and Explore are rebuilt on the new system. Home greets you by time of day, has a Resume card that picks up the session you left, real Projects / Updates / Saved counts instead of placeholders, and quick entries for a new project, an import, a Git clone or a store template.

THE PROJECTS STORE IS LIVE

• Explore now serves a real catalogue instead of only the templates bundled in the APK. The shelves, charts and categories come from the server, so the store can change without an app update, and the bundled templates stay as the offline floor.
• Install downloads, verifies a checksum, unpacks and adopts the project, and the progress follows the item everywhere it appears. Leave the screen and come back and the download is still there. Tapping again during an install no longer starts a second one, and a failure says why.
• Item pages get an Overview / README / Ratings / Changelog layout with a screenshot gallery and a lightbox.
• Search across the catalogue, browse by kind, and see install counts and sizes before you commit.

PUBLISH YOUR OWN PROJECTS

• Sign in with GitHub and submit a project for review. Browsing and installing still need no account at all, and the sign-in prompt only appears at the moment you ask to publish.
• Publishing packages the project on device and shows you exactly what is in the archive before you commit to it. Keystores, local.properties, .env and google-services.json are never uploaded, and the ones it found and dropped are listed on the page rather than removed silently.
• Up to six screenshots per submission, picked with the same picker the export flow uses.
• The publishing guide is a real guide now: what gets zipped, what is excluded, that a person reviews it, what happens when it goes live, and the actual limits. It used to just open Settings.
• Publish now sits above the export options when you share a project, so sharing with one person and publishing to everyone are two visible paths rather than one buried setting.

RATINGS, REVIEWS AND PROFILES

• Leave a star rating on any project, with a written review optional. Stars are what feed the average and the charts, so a rating never depends on you writing prose first.
• Mark a review helpful, report one, and if you published the project, reply to it. Moderators can take a review down, and hiding one actually moves the average rather than leaving it counted.
• Publisher profile pages: total projects, total installs and a rating weighted across the catalogue, so one five-star review cannot outweigh two hundred ratings. Follow a publisher from the page.
• Likes replace the old device-only saved list. Saving a project is the like, the count is public while who liked it stays private, and it now belongs to your account instead of one phone, so a reinstall or a second device keeps it. Likes made offline are kept and pushed when you are back on.
• Existing saved projects carry over.

NOTIFICATIONS

• A notification center for the whole app: a build finishing, a review being decided, an update existing for an installed project. Things you were absent for are still there at the next launch instead of being lost.
• Push notifications deliver the ones that matter with the app closed, so a review decided days later actually reaches you. Reviews, builds and agent results raise a tray entry; store updates, lessons and system notices wait for the next launch rather than interrupting you.
• A notify switch on the device that now genuinely turns delivery on and off, and says why if a change does not stick.

PLUGINS AND LANGUAGES

• A plugin no longer has to ship inside CodeAssist. Install a plugin as a separate app and CodeAssist finds it, checks it against the host version, and loads it alongside the built-ins. The Plugins screen splits into Built-in and Installed, and an installed plugin that failed to load says why.
• Adding a language is now a registration rather than an edit to the IDE itself. A language ships its own analyzer, its own keywords, comment markers and Enter behaviour, and its own highlighting, all as one plugin. custom-language-support.md walks the whole thing end to end.

FIXES

• Cloning and putting a project under version control crashed on Android 12 and below, and the failure took the whole app down rather than reporting a failed operation. It was the most common crash in 3.11.0 outside of native ones, and it could hit about a quarter of installs. Fixed on both counts.
• A cloned repository now always shows up in your project list. A clone that was not already a CodeAssist workspace was saved to disk and then never listed, so a successful clone looked like it had silently failed. Clones are now labelled for what they are: a CodeAssist project, a Gradle project, or Files when nothing recognises it, with a banner in the editor explaining the limits.
• You can delete a project. The delete control existed but could never render, so there was no way to remove a project from the app at all. Every project card now has an overflow menu, and deleting asks first and names the project.
• A cloned project's sources are visible again when the clone has no modules set up yet.

Full changelog: https://github.com/tyron12233/CodeAssist/releases/tag/v3.12.0

CodeAssist 3.11.0

🚀 CodeAssist 3.11.0

Git runs on the phone now, with GitHub sign-in, branches, history and diffs. Plugins can finally draw a full screen instead of a narrow drawer, and there is a guide for writing one.

VERSION CONTROL

• Git works on the device. A project written and built here had nowhere to go: no history, no branches, nothing to push, and the source-control panel in the rail just said "Coming Soon". It is a real panel now.
• Stage and unstage files, commit, pull and push, with the ahead and behind counts printed on the buttons themselves.
• Branches, history, diffs and stashes each open as their own screen, because a branch list does not fit in a sidebar on a phone.
• Sign in to GitHub from the app: it opens the normal GitHub device flow (a code you confirm in the browser), or you can paste an access token. Signed in, you can browse and clone your repositories.
• Clone a repository from the project picker, so you do not need an open project to get one.
• The panel is worded rather than drawn. Groups of files say what they are ("Ready to commit", "Edited but not included yet"), every icon has a tooltip, and committing is one button whose label follows a "Push after committing" checkbox.
• Accounts live outside any project and every secret is encrypted on disk, so exporting or sharing a project never carries your token.
• It is a plugin like the others: one toggle in Settings ▸ Plugins removes the panel and the Git engine together.

PLUGINS

• A plugin can open a full screen now. Screens registered by a plugin were never rendered, so a plugin could only draw inside its own dock, which on a phone is a drawer about 300dp wide. Enough for a list of files and nothing else.
• Back from a plugin screen returns where you opened it from, the editor or the picker, instead of one fixed place.
• Panels and screens can open an external link and reach their own detail views, so a plugin no longer needs the host to do it.
• The shell's placeholder source-control panel is gone. That rail slot belongs to a plugin, and a plugin claiming it inherits the rail position, the remembered open-panel choice and the phone bottom-nav entry.
• New guide: writing plugins. The plugin model was documented as built but there was nothing task-oriented. docs/writing-plugins.md walks it end to end, from a first plugin to extension points, services, settings pages, actions and the Compose UI surface, then reads the Git and AI Agent plugins as worked examples.

KOTLIN EDITOR

• coroutineContext[CoroutineName]?. offered no members at all. A generic operator (a[i], a(i)) now infers its own type parameters from what you pass it, not just from the receiver, and a class named as a value resolves to its companion the way Kotlin does.
• Enum members resolve. Color.RED.name reported "Unresolved reference" on your own enums, and a builtin enum decoded with no constants at all, so AnnotationTarget.CLASS read as unresolved and AnnotationTarget. completed empty.
• import kotlin.time.Duration.Companion. offered nothing. An explicitly spelled Companion now completes its members.
• items(list) { } inside LazyColumn offers the import that fixes it. The lightbulb was only reachable with the caret on the argument rather than on the call, a named argument no in-scope overload declares reported nothing, and a nested call offered an import that fixed nothing. The same call also stopped reporting a contradictory second error on top of the first.
• A value of function type is coloured the same wherever it appears. f() and f.invoke() in one body used to come out in two different colours.

ANDROID

• Another module's or an AAR's R resolves, both in the editor and in the build. With non-transitive R classes you have to name the package that owns a resource (com.example.base.R.string.x), and that form resolved nowhere below the app: the editor called it unresolved and :feature:compileJava failed with "com.example.base cannot be resolved". A dependency's BuildConfig and view bindings come into Kotlin files with it.

DEPENDENCIES

• Editing a dependency's version sticks. Changing a version, closing the project and reopening showed the old one again. Version edits, exclusions and newly attached dependencies are all written to disk when you make them.

RUN

• Your own exception type is caught again. An exception class of yours that extends a real one (class MyException : Throwable(...)) escaped the try that declared it whenever real code threw it back, so try { suspendCoroutine { it.resumeWithException(MyException()) } } catch (e: MyException) printed nothing and died uncaught. The same shape covers Optional.orElseThrow and a resumed suspend function.

PROJECTS

• One Import project entry on the picker, not two. The top-bar download action and the "Import project" card were not the same door: the top-bar one could only take a shared package. The card is the single entry and covers both a folder and a package.

Full changelog: https://github.com/tyron12233/CodeAssist/releases/tag/v3.11.0

CodeAssist 3.10.0

🚀 CodeAssist 3.10.0

A project you build here can now leave as a real Gradle project, Kotlin compiles in its own process instead of fighting the editor for memory, and the dependency, sharing and module screens have been rebuilt.

EXPORT AS A GRADLE PROJECT

• Your project can now leave as a Gradle build. Export it and you get a .zip holding your sources plus generated settings.gradle.kts, a build.gradle.kts per module, gradle.properties and the Gradle wrapper settings. Open it in Android Studio or run gradle build on it.
• It is on the export screen as a Format choice, next to the CodeAssist package you already had.
• What you configured comes with it: modules and how they depend on each other, every dependency (including BOMs, exclusions, and debug-only entries), namespace, SDK levels, version code and name, manifest placeholders, build types, flavors, build features and packaging rules.
• Compose, parcelize and serialization are switched on for you in the exported build, even though CodeAssist itself never needed a flag for them.
• A Java or Kotlin module with a main gets the application plugin wired up, so gradle run works.
• Anything Gradle cannot express is listed rather than quietly dropped: a signing keystore (it lives in the app, not the project), the annotation processors CodeAssist bundles, and any library with no Maven coordinate. You get the list on screen and as GRADLE-EXPORT.md inside the archive.

BUILD

• Kotlin compiles in its own process now. Android caps every app's memory no matter how much RAM the phone has, and compilation was sharing that cap with the editor and index. A compiler process starts once, keeps its state warm, and runs with a much larger heap: after the first compile of a session, later ones land in around 150 to 200ms, faster than before and without starving the editor.
• Settings ▸ Build Runtime carries the controls: Kotlin compiler execution (Compiler VM or In-process), the heap it may use, and how many run at once. Anything that goes wrong falls back to compiling in-process rather than failing your build.
• Shrinking with R8 no longer trips over a missing class from its own toolchain.

DEPENDENCIES

• Add Dependency is search-first. The five rows of chips and fields above the results are gone: it is a search box, one options line, then results. No more choosing Library or Platform before you can type. A BOM is recognised on its own and labelled where it appears.
• Results are two lines now, artifact and version first with the group underneath, so a dozen same-named artifacts are actually distinguishable.
• With an empty box you get the menu: the quick adds, plus Module and Local file.
• Scope and variant read as one line ("implementation, All variants") and expand to a wrapped set of chips, so nothing hides behind a horizontal swipe.
• The version-conflicts banner no longer opens itself on a project that resolves and builds perfectly well.
• Adding a repository actually works now. Adding one and re-adding the dependency it carries did nothing at all: the failed lookup was remembered by coordinate, with no memory of which repositories produced it, so nothing went back to the network for the rest of the session. Adding, removing or reordering repositories now re-probes what did not resolve.

PROJECTS

• One Import project action covering both a project folder and a .caproj package.
• A CodeAssist project folder can be imported. It could not before: a folder moved from another device, restored from a backup, or orphaned when app data went missing was rejected as "not an importable Gradle project" and there was no way to get it back into the picker.
• The folder is picked first and inspected, so the compatibility-or-convert question only shows for a Gradle build, where it means something.
• Export and import were rebuilt on Material 3, with the action pinned at the bottom instead of hidden below the form.
• An import preview now describes the project by its modules (app, Android app, 84 files, 3.0 MB) instead of a wall of file paths, with the full list one tap away.
• You can name a project as you import it, and see the folder it will land in. Importing the same package twice used to silently produce "Foo 2".
• Export lets you leave modules out, and keeps the selection buildable by taking dependants with them.

ANDROID

• The API levels are current: 21 through 36 (Android 16), and new projects target the newest by default. Everything sat at 34, which was not just cosmetic: a modern AndroidX library declares the compile level it needs and the build failed below it, so ordinary dependencies could not be used out of the box.
• minSdk now defaults to 26, matching what the templates already documented.
• manifestPlaceholders are supported, in the module settings and read from a Gradle import. A library whose manifest requires one (billing clients commonly do) merges instead of failing at packaging.
• The build warns when the installed platform it resolved is older than your compileSdk, instead of failing later on a missing symbol.

COMPOSE PREVIEW

• A preview running out of process now reports partially rendered the same way the in-process one does, instead of claiming everything was fine.
• The preview sandbox is enforced out of process. Since isolated previews became the default, the sandbox settings were being applied only on the fallback path, and blocked calls are now reported in the usual chip.
• A stock Material 3 Type.kt using Google Fonts rendered as "Can't instantiate abstract class FontFamily". Both defects behind it are fixed: a function that shares a name with a type is now called rather than constructed, and a font implementation reaching Compose from the interpreter answers for the methods its abstract parent left unimplemented.

EDITOR AND UI

• Module settings moved to Material 3, with a save bar that appears when you change something. Editing a field like namespace or minSdk previously left the form looking untouched.
• The Icon Manager scrolls smoothly. Artwork was resolved one icon at a time through the same single worker the editor uses for completion, so a typed keystroke could cancel it and leave tiles permanently blank, and every visible icon's paths were re-parsed on every frame.
• Apostrophes render as apostrophes. 47 strings showed a stray backslash.

RUN

• Console runs ship coroutines 1.11.0, so runBlocking works, and a version mismatch explains itself instead of failing with an unrelated error.
• A background thread that throws in your program no longer takes the whole build process down with it.

Full changelog: https://github.com/tyron12233/CodeAssist/releases/tag/v3.10.0

CodeAssist 3.9.9

🚀 CodeAssist 3.9.9

AIDL

• .aidl files build now. Put an interface in src/main/aidl, and CodeAssist generates the Stub and the proxy for it, so a bound Service actually compiles and runs.
• The whole language is covered: in / out / inout parameters, oneway methods, arrays, lists, maps, parcelables, constants, and pinned transaction ids. Structured parcelables and enums generate too.
• The editor knows AIDL. Syntax highlighting, a file icon and an aidl folder icon, and New ▸ AIDL File with an interface or parcelable template.
• Mistakes are flagged while you type instead of at the next build: a parameter missing its in / out / inout, a oneway method that returns a value, a misspelled or unimported type, a syntax slip.
• IFoo.Stub resolves before you have ever built the project, so writing the Service that implements it is not a wall of red squiggles.
• A library module ships its .aidl inside its AAR, and interfaces a module you depend on declares resolve from your own files.
• There is no setting to switch on. If the aidl folder has files in it, they get compiled.

FIXES

• Fixed the crash that made the Icon Manager unusable on Android 8.1 through 13. Opening it was a guaranteed crash on every device below Android 14, and it took the app-icon studio's image layers down with it. The icon picker also came up empty instead of listing anything.

Full changelog: https://github.com/tyron12233/CodeAssist/releases/tag/v3.9.9

CodeAssist 3.9.8

🚀 CodeAssist 3.9.8

ICONS

• New Icon Manager: browse the drawables and mipmaps in your project, search a bundled Material Symbols catalog, and drop an icon in as a vector drawable or as a Compose icon snippet.
• New App Icon studio: design a launcher icon, preview it at every density, and write the generated icons plus the manifest entries for you.
• The drawable preview understands a lot more XML now (layer lists, gradients, insets), so drawables that used to show up blank render properly.

XML AND LAYOUTS

• Layout files now flag an element that does not exist, with "did you mean" fixes that rename both the opening and closing tag.
• More layout checks: children under a view that is not a ViewGroup, an <include> with no layout, a <merge> that is not the root, a <fragment> naming no class, and the same @+id declared twice.
• In res/values: a declaration missing its name, and one name declared twice for the same R class.
• Attributes added by a quick fix or by the preview's attribute editor now follow the element's own formatting: one per line if that is how the element is written, inline if it is compact.

KOTLIN

• An infix operator that resolves to nothing is now reported instead of passing silently.
• A mismatched import now offers a fix.
• Parameter types that are primitive arrays are read correctly from library bytecode, so those signatures and completions are right.

FIXES

• Fixed a crash on startup that showed "Failed to start" on some devices.
• Ending a run now waits for threads the program started itself, so a background thread can no longer fail with "zip file closed" just after the run ends.
• KSP processors that bundle their own Guava now load it self-first, fixing failures in dexed processors.

Full changelog: https://github.com/tyron12233/CodeAssist/releases/tag/v3.9.8

CodeAssist 3.9.7

🚀 CodeAssist 3.9.7

SWING AND AWT

• Write and run desktop Swing programs on your phone. CodeAssist ships its own java.awt and javax.swing for the device, so a windowed program compiles against the real API and runs in the preview process.
• Windows appear in the Run pane with full touch and keyboard input, sized to your content pane.
• Widgets covered so far: labels and text fields, buttons and toggles, lists, scroll panes, borders, progress indicators, and modal dialogs including JOptionPane and JDialog.
• Two new project templates: Swing Desktop App and Swing Custom Painting.
• A GUI run stays alive until its last window closes, and a resized window repaints instead of showing a stale picture.

AI AND TOOLS

• An in-app MCP server (Streamable HTTP) plus an FTP asset server, so an external agent or a desktop tool can reach your project on the device. The HTTP server listens on loopback only, bodies are byte framed, and the FTP data port can be forwarded.

KOTLIN

• Extension functions declared inside an object or companion object are now seen and suggested. Completion offers them on a matching receiver and adds the import for you (import util.StringUtils.twice) when you accept one.
• A companion object's extension no longer reads as an unresolved reference inside its own class, in a property initializer, or in a subclass, and a nested object reached through with(Inner) { } resolves.
• Typing fun now suggests type names for a receiver, so an extension function can be declared straight from the popup, with the import added on accept.
• Implement members keeps suspend, the type parameters with their bounds, and vararg, so the stub it writes compiles.
• A missing import is flagged for a generated or project type used as a receiver.
• A renamed variable's leftover usages are flagged in receiver position too, not only in plain references.

JAVA

• Control flow is judged per method or initializer instead of per file, which clears three kinds of false error on valid code.

BUILD AND STABILITY

• Builds are back to full speed. The library dex warm added in 3.9.6 could double build times on the very projects it was meant to help. It now runs only where it can actually hit the cache, takes a single worker so it cannot starve a real build, and is opt-in.
• Far fewer crash reports on smaller devices. The forked build VM asked for more heap than some phones can reserve, and the abort that followed was filed as an app crash. The heap ladder is now bounded by device RAM, and a forked tool VM's abort is no longer reported as an IDE crash.
• Hilt projects build: the Gradle plugin's half of Hilt is now supplied on device, so @AndroidEntryPoint compiles.
• Compose preview: a call whose receiver lives in a non-exported package is bridged instead of failing.

UNDER THE HOOD

• The Java PSI host is handed the registry keys IntelliJ's Java support expects, so Java code intelligence stands up reliably.
• App and screen state is hoisted out of the composables, which keeps the UI layer easier to change.
• The on-device build benchmark follows the importer sync path again.

Full changelog: https://github.com/tyron12233/CodeAssist/releases/tag/v3.9.7

CodeAssist 3.9.6

🚀 CodeAssist 3.9.6

BUILD

• Java records build. A project with a record in it, or a dependency carrying one, failed dexing with "Attempt to create a global synthetic for 'Record desugaring'". Records now dex and merge normally.
• Two bundled processors on one module. Declaring two of Room, Moshi, Hilt or Glide failed source generation with "Duplicate class". Each bundle ships its own copy of the shared libraries, and the first one on the classpath now wins, on device exactly as it does on desktop.
• Library sources are published again, so parameters from third-party Java libraries read as their real names instead of p0/p1, and Go to Source opens real source instead of decompiling.
• Extension points for build systems. Plugins can contribute build tasks, import a foreign build system's files into the project model, and write dependency declarations back into the build files. The Gradle path now runs through the same seams a third-party importer would.

ANNOTATION PROCESSORS

• A runtime too old for the bundled processor is reported up front. Pinning an older Hilt used to produce a wall of "cannot be resolved" errors in every generated file. The build now names the missing symbol and the coordinate to bump, before any processor runs.
• A banner in the editor shows the same problem on project open, with no file open, offering Update (or Downgrade) to the version the IDE bundles, or Build anyway if you want to proceed regardless. It lays out properly on a phone, and several affected modules collapse behind one row.

SIGNING

• Keystores a current keytool produced now import. They failed on device with "SecretKeyFactory not available" because Android's crypto provider has no PBKDF2. .jks files could not be opened at all. Both formats are read now, and the imported key keeps its identity and fingerprints.

KOTLIN

• import okhttp3.MediaType.Companion.toMediaType then "application/json".toMediaType() no longer reads as unresolved. That is the standard OkHttp and Retrofit idiom.
• An unimported LocalContext (or any Capitalized top-level val, which is every CompositionLocal) is now flagged, with an import lightbulb.
• An object is colored as an object everywhere it is used, not just where it is declared, whatever case it is named in.

EDITOR

• A horizontal scrollbar, on by default, under Settings -> Editor. It appears only when a line runs past the right edge, and it costs the document no height.
• Panning diagonally no longer stalls when the drag starts near the drawer edge.
• A press left resting on the screen no longer swallows the swipe that follows it.

PERFORMANCE

• The project, module, library and resource dexing scopes now run at the same time instead of one after another, so a single-input scope no longer leaves every other worker idle.
• A dexed library records that it is complete, so warm builds and the layout preview stop re-proving it file by file.
• External libraries can be dexed into the shared cache before you ever start a build.

Full changelog: https://github.com/tyron12233/CodeAssist/releases/tag/v3.9.6

CodeAssist 3.9.5

🚀 CodeAssist 3.9.5

A stability and editor-quality patch: local functions finally resolve like real declarations, Java parameter names are visible from Kotlin again, big files scroll smoothly, and the top on-device crashers are closed.

KOTLIN

• Local functions work properly. A fun helper() declared inside another function used to light up with errors on code that compiles fine: any call with arguments was flagged Too many arguments (expected 0), named arguments were rejected, and a recursive call reported Unresolved reference. Local extension functions (fun String.twice()) could not be called on their receiver at all, and a local no longer loses to a top-level function of the same name.
• The same fixes reach the Compose preview and console Run, where local functions were silently returning wrong values: a defaulted parameter (fun g(a: Int = 3)) came back as null when omitted, vararg took only one value, and named arguments bound in the wrong order. Local extensions and ::localFunction references now run too.
• Java parameter names are visible from Kotlin. They had degraded to p0, p1 everywhere. Names are now recovered from the bytecode itself where the library ships them, from attached sources otherwise, and from a live parse for your own .java files.
• Parameter name hints at Kotlin call sites. Literal arguments now show which parameter they fill, matching the Java side.
• A missing import is finally reported. viewModelScope and withContext used to sit unmarked in a file that would not compile, with no import quick-fix offered. Both now flag and offer the import. A companion object in the class no longer silences every other missing import.
• Import lines are colored. An imported withContext reads as the suspend function it is, instead of plain white text.
• Go to Declaration follows your imports. In a file importing androidx.compose.material3.Text, clicking Text("...") landed on org.w3c.dom.Text, an unrelated class from android.jar. Hover and quick doc followed it there too.

JAVA

• import static Type. now completes the class's static methods and fields, not just nested types, and stops offering private ones.
• Full record support: component accessors in completion, resolution, go-to-definition, hover, and arity checking on the canonical constructor.
• Fixed a hang in the diagnostics pass on an unqualified unresolved reference.

EDITOR

• Large files scroll and open much faster. Soft-wrapped scrolling no longer rebuilds its whole line map every frame, opening a file no longer tokenizes the entire buffer up front, and the indent guides, sticky headers and draw palette stopped redoing per-frame work.
• The auto-import lightbulb stayed hidden until you undid something (#1495). It now reappears as soon as the analysis lands.
• Horizontal scrolling near the right edge was stolen by the tool-window swipe area (#1493). Swiping now scrolls your long lines and only opens the drawer once there is nothing left to reveal.
• Diagnostic chips froze scrolling when your finger started on one, and a chip past the longest line could not be scrolled to.
• Reformat on save no longer drags the caret to the start of the line.

PROJECT

• Moving or copying a source file rewrites its package to match the new folder, and updates every file that imported it. Kotlin was previously not handled at all.
• New inspection for a package that does not match the file's location, with a "Set package to ..." quick-fix.
• A project whose module manifests are damaged now opens instead of failing.

STABILITY

• Fixed the top crash on device: a repeated key in the editor tab strip took the whole editor down. Tabs now carry their own identity, so a duplicate path can no longer crash the strip.
• Fixed the same class of crash in the Dependencies pane, where one coordinate can legitimately appear twice.
• Fixed a crash from layout-attribute completion when the caret moved back while the popup was still catching up.
• Closing a project could take the whole app down through a build or permission screen. It now degrades quietly.
• The real view preview could crash the app from its render thread instead of just failing the preview.
• The Dependencies screen no longer reports every declared dependency as unresolved when you leave it mid-resolve.

ANDROID BUILD

• Fixed "There was a problem while parsing the package" on install for apps using Play Services Ads or Play Billing. Distinct <queries><intent> entries were being merged into one malformed element.
• KSP now loads a processor's own Dagger runtime instead of the app's.

OTHER

• Crash reports now carry the OS tombstone for native crashes and the peak heap from editor sessions, so the remaining native and out-of-memory crashes can actually be investigated.
• The show-ads toggle asks again once per update. Turning ads off is still free and still sticks until the next version.

Full changelog: https://github.com/tyron12233/CodeAssist/releases/tag/v3.9.5

CodeAssist 3.9.4

🚀 CodeAssist 3.9.4

COMPOSE PREVIEW

• Custom-theme previews render again. An app with its own theme (Jetsnack-style JetsnackTheme.colors) drew a grey or blank surface in the isolated preview process and reported No ... provided. A theme value declared in a top-level val was being re-created mid-render, so what the theme provided no longer matched what a composable read back.
• First preview on a large project is much faster. Opening a preview used to lower every function in every file it touched. It now pulls only what the preview actually reaches: on a large sample the preparation step went from about 3.5s to under half a second.
• Previews stay fast after a restart. Lowered code is cached on disk per module, so reopening a project decodes it instead of resolving everything again. A file that took 1.4s cold now loads in about 20ms.
• One broken composable no longer blanks the whole preview. A nested composable that throws is contained and reported in place, so the rest of the preview still draws.
• Gradients and other extension-property code resolve. A file-level extension property read inside a receiver scope (a Density extension used by a gradient) silently failed, which collapsed the gradient to zero width and drew nothing.
• More interpreter fixes found by sweeping a real app's previews: value classes handed to theme providers and returned from lambdas, Color/Dp boxing at reflective call boundaries, extension-property overloads, isEmpty/isBlank, Double arguments passed to Float parameters, PascalCase companion factories, SAM constructors, scopes, and default-argument helpers that release builds leave non-public. Dispatch failures now explain themselves instead of failing silently.

JAVA EDITOR

• Member completion no longer hides what you are typing. On a wide receiver such as an Android View or Button subclass, the popup was capped at 200 entries and then filtered without asking for more, so a member below the cap could never be reached by typing. button.setText came up empty. It now refetches as you narrow the prefix.
• Inherited members are offered. Bare-name completion inside a subclass did not suggest anything it inherited, so findViewById and friends never appeared inside an Activity. They do now.
• A lot of other names were missing too: for and for-each loop variables, catch parameters, try-with-resources variables, lambda parameters, instanceof and switch pattern variables, type parameters, and static imports. All of them complete now.
• Fewer duplicate rows. An inherited method that a subclass overrides was listed once per level of the class hierarchy; now only the one you would actually call is shown.
• All overloads are shown. print(int), print(String) and the rest were collapsed into a single row, hiding the signature you wanted.
• Completion respects context better: a supertype's inaccessible members stay hidden, and a static method only offers static members.
• New: annotation attribute names inside @Anno(...), and the Type.class literal.

EDITOR

• Asset files are no longer reported as broken Java. A file under res/raw (or a stray .txt/.json/.csv/.properties in a source folder) was parsed as Java, so its entire contents came back underlined as syntax and unknown-symbol errors. Those files now open as plain text with no diagnostics. XML under res/raw keeps its well-formedness check but is no longer treated as an Android resource.

AI AGENT

• Model Context Protocol support. The agent can now talk to MCP servers over stdio, so external MCP tools are available to it. (Community contribution, #1482)

Full changelog: https://github.com/tyron12233/CodeAssist/releases/tag/v3.9.4