Kotlin Jump

Kotlin Jump demo

The Android Studio experience for Kotlin & Java in VS Code.
Fast navigation. Deep refactor. Full Android workflow.
No JVM. No language server.

⚡ < 1 ms lookups • ⚡ 3,000+ files in < 500 ms • ⚡ 109× faster than JVM parsers

Click → Jump → Done.

_{Open VSX serves Cursor, VSCodium, Windsurf, Gitpod, and most other VS Code forks.}

Why this feels different

Other Kotlin extensions wait. JVM startup, background indexing, "loading…" before you can click anything.

Kotlin Jump skips all of that. No LSP. No JVM. No waiting.

Once you get used to it, everything else feels slow.

✨ Recent

⚡ Fast editing. Named arguments, postfix completion, live templates, surround with, smart join: the IntelliJ gestures, in the lightbulb.
🧭 Structure views. Compose Outline and the Android project view in their own activity-bar container, full height.
🧹 Dead weight. Usage badges on resources, dependencies and manifest entries. Everything flagged unused offers its removal.
🧽 One dead code sweep. Imports, parameters, private declarations, locals and write-only variables, found across the workspace in one scan and cleared in one preview.
🔬 Static execution. Lifecycle leaks, dispatcher misuse and Room migration drift, caught before you run.
💡 Quick fix sweep. Missing lifecycle releases, expired TODOs, !! rewrites and missing when branches, all one lightbulb away.

Full changelog →

Features

Jump anywhere instantly.

Shortcut	Action
`Cmd+Click` / `F12`	Go to Definition
`Cmd+F12`	Go to Implementation
`Shift+F12`	Find All References
`Alt+F7`	Find Usages

Kotlin, Java, Compose, AndroidX. Same speed across your project and your dependency JARs.

Cmd+Click adapts automatically.

You click on	It goes to
Interface	Implementation
Interface method	Override
Method (1 usage)	That usage

No menus. No thinking.

Find Usages

Alt+F7. Every usage, grouped by file, with previews.

grouped by file
inline previews
toggle tests on/off
toggle @Preview
optimized for large codebases

⚡ Fast Editing

The IntelliJ editing muscle memory, rebuilt for VS Code. No LSP required.

Add names to call arguments

createTrainer("Ada", 36, true) becomes createTrainer(name = "Ada", age = 36, isChampion = true) in one action, straight from the lightbulb.

Postfix completion

Type pikachu.null and the completion provider expands the null check for you. Also .notnull, .let, .for, .when.

Live templates

prev + Tab writes the whole @Preview + @Composable block. logd, logt, comp, vm, lazyv work the same way.

Surround with

Wrap the selection in try/catch, if, when, let, run or apply. Indentation follows the enclosing block, cursor lands where you type next.

Smart join lines

Ctrl+Shift+J fuses split string literals into one, merges consecutive comments, glues call chains. Also in the lightbulb.

🎨 Resource Intelligence

Extract string resource

A hardcoded UI string moves to strings.xml (escaped, snake_case name generated) and the call site swaps to stringResource(...). Both files shown, $variables become placeholders.

Resource shadowing

Two modules define the same resource name? The badge tells you which definition wins, and where the loser hides.

Reverse string map

Edit a value in strings.xml and watch the folded previews repaint in every consumer on save. Hover the entry to learn which SCREENS display it, by name.

🧭 Structure Views

A dedicated Kotlin Jump container in the activity bar, full sidebar height.

Compose Outline

The UI structure of the composable under your caret, without building: branches labeled (if (loading), else, when), loops marked ×items, recursion cut with ↺.

Android project view

Modules grouped the Android Studio way: manifests, kotlin+java, res by type, Gradle scripts.

Screen Flow Map

Your navigation graph as a diagram: routes, screens, and who reaches whom.

UDF X-Ray

CodeLens on every ViewModel state property: who writes it, who reads it.

🔬 Static Execution

Checks that read like runtime knowledge, before you run anything.

Lifecycle pairing

requestLocationUpdates in onResume with no removeUpdates in onPause? The squiggly lands on the call and the hover spells out the leak. The quick fix writes the missing release.

Dispatcher lens

withContext / launch / flowOn blocks annotated with their dispatcher. View access off Main and network on Main get softly flagged.

Room migration drift

An @Entity field with no ADD COLUMN in any migration, or a hole in the chain (1→2, 3→4, no 2→3), caught before the upgrade crash.

🧹 Dead Weight

Everything the project carries for nothing, visible and deletable in place. Every no-usage flag offers its removal through the lightbulb.

Unused imports

Dead imports gray out as you read, alias traps included. One quick fix sweeps them all.

Unused parameters

A parameter nobody reads warns on the declaration. The quick fix removes it and every argument passed to it, across files, behind the Refactor Preview.

Unused locals

Variables never read, named lambda parameters nobody uses, catch bindings that ignore the exception. The fix deletes the variable when its initializer is safe to drop, and keeps the call when it is not.

Unused resource files

Layouts, menus, anims and raw files nothing in the project references. The quick fix deletes the file with all its density variants at once.

The whole sweep

Find Dead Code runs every check above across the workspace in one pass, on the files you do not have open. Clean Dead Code in the Workspace clears everything with a safe fix in a single preview.

Unreferenced symbols

The classes, objects and functions that nothing in the project references, found across files rather than within one. The fix removes the declaration, the imports it leaves dangling elsewhere, and the file itself when nothing else is in it. Symbols only the tests reference get their own category, without a removal.

Unused resource keys

The entries inside values/*.xml that nothing references: strings, colors, dimensions, styles, attributes, integers, booleans, arrays and plurals. The fix removes the key in every configuration variant at once, values-night and values-fr included, in one preview.

Dead islands

Groups of declarations that reference only each other and are referenced by nothing else. Two functions calling each other with no outside caller both look used to every per-symbol counter; Find Dead Islands sees through it. Any mention it cannot place inside the island itself counts as life: XML, ProGuard, string literals, DaggerX naming. Uncertainty always keeps code alive. The fix deletes the whole island in one reviewed change, stale imports included. If a report looks wrong, scripts/scan-dead-islands.ts --why traces every verdict, and // kotlin-jump:ignore dead-island silences a file's islands while you tell us about it.

Resource usage badges

Per-resource usage counts inside values/*.xml. Zero means removable.

Dependency usage badges

build.gradle.kts shows how many files import each dependency. A library at 0 imports is pure APK weight, and the lightbulb offers the deletion.

Manifest necessity

Permissions and components checked against real code: no usage found badges, risk pills, and removal quick fixes with library-aware wording.

✂️ Editor Comfort

Method separators + SQL in @Query

IntelliJ-style separators between members, and real SQL syntax colors inside Room @Query strings, single-line or triple-quoted.

Recent locations

Shift+Cmd+E style picker over your navigation history, with previews.

📱 Android Run Button

Build, install, launch. One click.

No setup. Detects your app module, picks the right Gradle install task, launches on the connected device or emulator.

No device connected? Finds your AVDs and offers to start one.

Working in a monorepo or with several product flavors? See Android setup →.

💡 Saving time on every Cmd+R? Help other Android devs find Kotlin Jump → rate it on ⭐ Marketplace or ⭐ Open VSX. 30 seconds, real impact.

🧵 String Resource Folding

Stop jumping to strings.xml.

Text(text = R.string.button_ok)

// becomes

Text(text = "OK")

Android only.

🌍 Locale grid on hover

Hover any R.string.* reference to see every translation side by side. No hunt through values-*/strings.xml.

Code Lens

Always-visible context.

N usages. Click to open Find Usages.
M implementations. Click to list all implementors.
▶ Run / ⏱ Debug above @Test methods. Gradle-backed, wired into Test Explorer.

No hover. No guessing.

Developer Productivity

Removes the tiny frictions you hit all day.

Shortcut	Feature
`Cmd+T`	Workspace Search (`@class:`, `@fun:`…)
`Cmd+Shift+O`	File Outline
`Alt+Shift+T`	Go to Test
`Alt+Shift+P`	Composable ↔ Preview
`Shift+Alt+O`	Organize Imports
Hover	Signature, KDoc, types
Right-click	Move File, Copy FQN

Back and forward, with line and column restored, not just the file.

Shortcut	Action
`Cmd+Alt+←`	Navigate Back
`Cmd+Alt+→`	Navigate Forward

The way IntelliJ does it. Without IntelliJ.

Inlay Hints

See what matters, inline.

Parameter names at call sites. Clickable to navigate to the declaration.
Inferred types on val / var. Double-click to insert.

Kotlin Quality of Life

Signals you didn't know you needed, right where the code lives.

⚡ Suspend Call Markers

Every suspend call is a potential pause. Every dispatcher switch is a potential thread hop. Kotlin Jump marks both, inline and live.

⚡ on every suspend call in a coroutine body.
🧵 IO · 🖥 Main · ⚙ Default dispatcher badges on withContext and launchers.

Know your pauses. Know your threads. Before the UI freezes.

⏰ Overdue TODO Highlight

Date your TODOs and they hold you to it.

// TODO(2025-01-01): migrate to Room   ← red, that ship has sailed
// TODO(2027-06-01): optimize later    ← quiet until the day comes

Once the date passes, the TODO turns red. No config, no ceremony. Turn it off with kotlinJump.todoExpiry if you prefer your debt silent.

🔐 Permission hover

Hover any Android permission and know what you're asking for.

Manifest.permission.ACCESS_FINE_LOCATION
// → dangerous · requires a runtime request
// → "Allows the app to get the precise location of the device."

Works on Manifest.permission.* constants and on "android.permission.*" strings, including inside AndroidManifest.xml. Covers 61 permissions, with migration notes on the legacy ones (WRITE_EXTERNAL_STORAGE, BLUETOOTH, USE_FINGERPRINT).

And in the manifest itself, every <uses-permission> line carries a risk pill:

<uses-permission android:name="android.permission.INTERNET" />   🟢 normal
<uses-permission android:name="android.permission.CAMERA" />     🟡 dangerous
<uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW" />  🔴 special

Your permission review, at a glance. Toggle with kotlinJump.manifestPermissionBadges.

♿ Compose accessibility nudges

Two TalkBack traps, caught while you type.

Image(painter = p, contentDescription = null)  ⚠ a11y: decorative?
Box(Modifier.clickable { open() })             ⚠ a11y: role?

Hints, not errors: null is right for decorative images, so the hint asks instead of asserting. Hover it for the fix. Toggle with kotlinJump.composeAccessibilityHints.

🔢 Flow chain step badges

Long pipelines, numbered stages.

flow
    ① .map { it.name }
    ② .filter { it.isNotEmpty() }
    ③ .collect { render(it) }

Multi line Flow and collection chains get ① ② ③ badges, so you can talk about "step 2" instead of counting dots. Single operators stay clean. Toggle with kotlinJump.flowChainBadges.

🚫 Deprecation, visible

Deprecated symbols get native strikethrough, at the declaration and at every resolved call site. Hover shows why and what to use instead:

@Deprecated("Use fetchV2", ReplaceWith("fetchV2(id)"))
fun fetch(id: Int)

fetch(7)   // struck through · hover → "Use fetchV2" + the replacement snippet

Multi line @Deprecated(...) annotations included. When two same name symbols could match, the hover stays quiet rather than flagging the wrong one.

⏱ Cron and duration literals, translated

val schedule = "0 */6 * * *"   ↳ every 6 hours
val timeout  = "PT1H30M"       ↳ 1 hr 30 min

No more counting cron fields on your fingers. Shapes the translator cannot phrase cleanly show nothing at all, because a wrong translation is worse than none. Toggle with kotlinJump.literalTooltips.

▶ Run Gradle tasks from the build file

Every tasks.register(...) in a build.gradle.kts gets a Run task lens. Click it and the task runs in the integrated terminal, module path resolved: ./gradlew :app:generateProtos. Desktop only.

🎯 KMP target coverage on expect declarations

expect fun platformName(): String     [android ✓] [ios ✓] [js ✗]

Which platforms implement this expect? The badge row says it before you go looking. Targets come from your real source sets, no Gradle parsing. Click jumps to the actual (picker when several targets have one). Toggle with kotlinJump.kmpTargetBadges.

⚠ Data class body fields, exposed

data class User(val id: Int, val name: String) {
    val cache = emptyList<String>()   ⚠ not in equals/copy
}

Body properties are silently excluded from the generated equals(), hashCode(), and copy(). Two instances differing only in that field compare equal. The hint says so before the bug does. Toggle with kotlinJump.dataClassFieldWarnings.

🎨 Vector drawable preview

Open any <vector> XML drawable and a rendered preview appears side by side automatically. Hover any R.drawable.* reference for an inline thumbnail. The gutter shows a mini render next to every reference. Click the CodeLens above the XML file to open the dedicated preview panel.

📦 Library Sources

Go to Definition works inside your dependencies too. Out of the box.

Kotlin stdlib ships bundled (~600 KB). Compose, Coroutines, AndroidX and other JARs are indexed from your Gradle/Maven cache automatically, or downloaded directly from Maven Central in one click.

$(library) KJ: 42 libs · JDK · stdlib ✓

No language server. No background process. No JVM.

Cmd+Click straight into `kotlinx.coroutines`

KDoc on hover, straight from the JAR

KDoc extracted directly from the matching -sources.jar.

🤖 AI Assistant

Query your codebase in natural language.

@kotlin-jump find all implementations of Repository
@kotlin-jump doc for BattleEngine
@kotlin-jump usages of loadData

Also exposes an MCP endpoint for Claude Desktop and other AI tools, so you can query the index without VS Code open.

No setup. Works immediately.

🧠 What it understands

Every Kotlin construct: classes, data/sealed classes, objects, enums, functions, properties, typealiases, @Composable. Every Java construct: classes, interfaces, enums, records, annotations.

Companion Mode

Already using the JetBrains Kotlin LSP? Kotlin Jump detects it automatically and disables overlapping providers (hover, outline, rename, semantic tokens), keeping only its fast navigation layer.

Auto-detected. Tweak via the kotlinJump.companionMode setting if needed.

Pair with detekt-lsp for live Detekt diagnostics in any LSP editor (pre-alpha).

🌐 Web support

Kotlin Jump runs on vscode.dev and github.dev: navigation, Find Usages, Code Lens, folding, hover, and the AI chat participant all work with no backend. Android Run, ADB, Logcat, and JAR source scanning need a real machine behind the editor. They work as-is in a GitHub Codespace opened in a browser tab, since VS Code detects the Codespace's Node backend and loads the full desktop feature set automatically. See doc/web-support.md for the exact breakdown.

Configuration

Search Kotlin Jump in VS Code settings (Cmd+,). All defaults work out of the box. No tweaks required for 95 % of projects.

One exception: kotlinJump.testTaskOverrides. The test runner picks testDebugUnitTest for Android modules and plain test otherwise, but it can't see an Android plugin applied indirectly through your own convention plugins. Set the task explicitly when that's the case, or when a flavor makes testDebugUnitTest ambiguous:

"kotlinJump.testTaskOverrides": {
  ":app": "testDebugUnitTest"
}

Multiple project folders in one workspace: this setting reads from each folder's own .vscode/settings.json, not the shared settings block of a .code-workspace file, so two folders with their own :app module can each get a different task.

⭐ Like Kotlin Jump?

If it shaved minutes off your day, even 30 seconds of your time would mean a lot. Every rating helps other Android & Kotlin devs find this.

Found a bug or have a feature idea? Open an issue. Answers usually within 24 h.

🔽 Install

Search Kotlin Jump in your editor's Extensions tab (Cmd+Shift+X), or install directly from Marketplace (VS Code) or Open VSX (Cursor, VSCodium, Windsurf).

VSIX

For offline installs (machines without internet access), grab the latest .vsix from GitHub Releases:

code --install-extension kotlin-jump-1.42.326.vsix

Build from source

See CONTRIBUTING.md for the full dev setup, or quickstart:

code --install-extension kotlin-jump-1.42.326.vsix

Companion tools

Kotlin Jump : this extension.
detekt-lsp : Live Detekt diagnostics for any LSP editor (pre-alpha).
SearchDeadCode : Dead code detection for Android (Rust CLI on Homebrew).

Maintained alongside elumine-dev by Kevin Doremy.

Kotlin Jump: Fast Kotlin & Android Studio Navigation

Elumine