Documentation

Releases

RSS

Release history for the IntelliJ plugin and compiler plugin.

Latest on Maven Central1.3.0

Latest

2026-05-02

HotSwan Palette

  • AI-driven visual iteration with zero-failure edits. New IDE-integrated design exploration surface that turns color, spacing, corner radius, typography, and density tuning into a side-by-side visual pick.
  • An AI agent generates N variants of the current screen on device. Every variant lands in well under a second through literal-patching without rebuilding the app. The chosen variant is written back to source as the new canonical value.
  • Available as a built-in IDE panel (web-based 9-grid with click-to-pick) and as a first-class MCP tool (hotswan_explore_palette) so any compatible agent runtime can drive it from outside the IDE.
  • Zero-failure guarantee by construction: every edit Palette can propose passes through the literal-patching pipeline, so the worst case is a "weird color, pick another" decision rather than a broken app or compile error.
  • Five iteration axes at MVP: color (Material 3 dynamic schemes + curated palettes), spacing (4dp grid snap), radius (sharp/rounded/pill), typography (compact/default/comfortable scales), and density (composite macro).

HotSwan Meta

  • Compile-time metadata for sub-millisecond reload classification. The compiler plugin now embeds structured metadata directly into every transformed composable at compile time, replacing runtime bytecode analysis with instant lookups.
  • Changes to non-composable utility code now invalidate exactly the right composable scopes instead of triggering a broad recomposition.
  • Cached values inside remember { } blocks are now preserved across reloads when the slot's key structure is unchanged, avoiding unnecessary recomputation of expensive state.
  • Reload classification (in-place, structural redefine, or full rebuild) is now decided from pre-computed metadata instead of heuristic bytecode comparison.

Compose 2026.04 BOM Compatibility

  • Substantial rework of device-side invalidation for the new Compose runtime and its LinkedBuffer-based slot table. UI updates now reliably reach all affected scopes, including ones the new runtime would previously skip.
  • Lambda body changes inside composables are now correctly detected and applied. Previously, stale cached references could keep old UI alive across reloads.
  • Restored correct "first hot reload after launch" behavior by waiting for the UI to fully settle before capturing the baseline.
  • Hardened recovery path for structural changes: prefers minimal targeted invalidation and only falls back to full recomposition when strictly necessary, eliminating the brief flash that occasionally appeared on edge-case reloads.

Reliability Fixes

  • Closure-capture invariance detection: The reload classifier now checks constructor-arity invariance on anonymous closure subclasses before deciding in-place reload. Catches edits like lifting a CompositionLocal.current read into a previously-closed lambda that would crash inside LazyLayout subcomposition. Affected reloads now fall back to full-rebuild transparently.
  • Cross-generation bytecode compatibility for synthetic property accessors: Fixed "app crashes on launch when plugin is enabled" failures caused by the isolation pass invalidating Kotlin's synthetic accessor invariants. The var foo: X; private set pattern in ViewModel state holders now works correctly.

2026-04-29

Performance

  • Dramatically faster first hot reload: The first reload after launching the app used to spend 20 to 60 seconds in "Compiling..." before the UI updated. Three coordinated fixes inside the warm-up and reload pipeline now keep that work continuous instead of throwing it away on every reload, so the first reload completes in roughly the same time as every subsequent reload.

Literal Patching

  • Compose hoisted lambda detection: Fixed primitive literal hot reload silently doing nothing for composables whose body the Compose compiler hoists into a ComposableSingletons field. Affected most Lazy containers, Scaffold slots, and any composable whose entire body went through composableLambdaInstance.
  • Automatic client-literals dependency: Adding debugImplementation("com.github.skydoves.compose.hotswan:client") no longer requires a separate client-literals line. The literal-patch runtime is now an api dependency of client, so HotSwanLiterals is on the consumer's compile classpath automatically.
  • literalPatching opt-out: New literalPatching flag on the hotSwanCompiler { } extension and a matching IDE Settings checkbox, default true. Set hotSwanCompiler { literalPatching.set(false) } and uncheck the IDE setting to fully disable the feature.

2026-04-28

Multi-Module & KMP

  • Multi-module first-class support: Hot reload now works out-of-the-box for the dominant modern Android pattern, Composables in :features:* / :core:* library modules with an app aggregator on top. New applyHotReloadTransformationToLibraries flag (default true) on the hotSwanCompiler { } extension covers an entire repo from a single :app setting.
  • KMP shared module support: The new com.android.kotlin.multiplatform.library plugin (KGP 2.x) is now properly detected. The compiler-plugin-pre classpath wiring now reaches KMP shared modules' androidMain / androidDebug source sets, so literal patches and full bytecode transformation work in apps like kotlinconf-app and any project where Composables live in a KMP shared module.

Hot Reload Improvements

  • Inner-lambda edits no longer trigger full rebuild: Edits like .background(Color(0xEFC2929A)), swapping a RoundedCornerShape, or any modifier-chain change in an inner lambda body were misclassified as structural. Inner lambdas are now redefined at runtime directly, and the parent recomposes naturally on the next pass.
  • Skippability bypass for literal patches: Composables that read patched literals but observe no other Compose state were silently skipped during recomposition. Both literal-patch and body-only paths now force a full recomposition pass on the affected scope, ensuring changes are always reflected on the next frame.

Fixes

  • rememberSaveable ClassCastException fixed: RememberKeyTransformer was reusing wrapCacheCall for both cache() and rememberSaveable(), but their arguments[0] means different things. New wrapRememberSaveableCall locates the composer by parameter type.
  • KMP source-set filenames (Foo.android.kt) sanitized for valid $Fn$ identifiers.
  • Kotlin context(...) parameter composables skip isolation.
  • Balloon diagnostics for "0 transformed classes detected" and app-module-mismatch suggestions.
  • Stale Version.kt baked into client AAR fixed.

2026-04-24

  • KMP configuration cache fix: Kotlin Multiplatform projects with org.gradle.configuration-cache=true would silently push stale bytecode to the device, so edits only became visible after navigating away and back. HotSwan now auto-detects KMP projects and disables the Gradle configuration cache for its own invocations only. Pure Android projects and your regular ./gradlew builds are untouched.
  • Literal patch subcomposition coverage: Literal-only edits (numeric, string, float values inside composable bodies) inside LazyColumn/LazyRow/Scaffold/LazyVerticalGrid items or any other SubcomposeLayout-based container now reflect on the first frame instead of requiring navigation back-and-forth. The invalidation path now reaches both root compositions and active SubcomposeLayout subcompositions for this safe subset of changes.
  • Failed composition recovery restored: Fixed a "first few reloads work, then the screen freezes" regression on Compose 1.8+ apps. The client was reading Recomposer._failedCompositions as kotlin.collections.Set, but it has been a MutableScatterSet (from androidx.collection) since Compose 1.8, so the size check always returned -1 and the surgical reset + Activity.recreate() recovery chain never fired after a transient recompose failure.

2026-04-23

  • Compose 1.11 LinkBuffer compatibility: apps using the new linkbuffer SlotTable implementation (ComposeRuntimeFlags.isLinkBufferComposerEnabled = true) no longer crash on hot reload. The client auto-detects which SlotTable backend the running app uses (gapbuffer vs linkbuffer) and adapts reflection and slot-table operations accordingly.
  • Zero behavior change for existing users: Compose 1.10 and earlier (plus Compose 1.11 with linkbuffer flag disabled, which is the default) continue to work identically. The gapbuffer code path is preserved bit-for-bit.
  • Wider subcomposition coverage: SubcomposeLayout scanning now also picks up paused prefetched compositions, so lazy item subcompositions are pre-expanded correctly before invalidation.

2026-04-21

  • Lifetime license save race fix: the post-verification modal dialog was blocking the EDT while the async saveSettings() coroutine was still flushing to disk. Replaced with a balloon notification so the save completes before the user restarts.
  • Auto re-verification on startup: users whose license partially persisted in older versions (username saved, verified flag lost) now auto-recover on project open via a background sponsor re-check.
  • Surfaced save failures: saveSettings() exceptions are now shown as warnings instead of being silently swallowed.

2026-04-21

  • Lifetime license paywall race fix: removed the 5-second grace-period recheck that could replace the activated UI with the paywall right after startup. Feature access remains gated at runtime.
  • Immediate verification persist: after successful lifetime verification, settings are flushed to disk immediately so the verified flag survives abrupt IDE shutdown.

2026-04-21

  • Lifetime license stability: fixed lifetime license reverting to trial after IDE restart. Grace period timer no longer interferes with lifetime sponsors.
  • Safer re-verification: background re-verification no longer revokes lifetime license on temporary server failures.

2026-04-21

  • Lifetime license persistence fix: fixed lifetime license not persisting after IDE restart due to duplicate service registration.
  • Instant paywall removal: after successful lifetime verification, the tool window now refreshes immediately without requiring a restart.
  • Google Sheets fallback: sponsor verification now falls back to Google Sheets if the GitHub GraphQL API is unavailable.

2026-04-17

  • Lifetime license via GitHub Sponsors: one-time $200+ sponsorship grants a lifetime license. Verify directly from the plugin settings or the HotSwan website.
  • Screenshot demo mode: captureAllPreviews now enables Android System UI Demo Mode for deterministic status bar (fixed clock, battery, signal) across captures.
  • Multi-display screenshot fix: fixed corrupted screenshots on emulators with multiple displays (Resizable Experimental).

2026-04-10

  • Global MCP configuration: configure the MCP server once and use it across all projects. The server auto-discovers the project directory from the working directory.
  • Per-preview render delay: use @PreviewScreenshot(renderDelay = 5000) to set custom capture delays for previews that load network images or async content.
  • CI screenshot generation: captureAllPreviews now works in GitHub Actions with android-emulator-runner for automated preview catalog generation.

2026-04-04

Instant Literal Patching

  • Primitive literal changes (strings, integers, floats, longs, doubles, hex colors) now reflect on device in under 500ms, completely bypassing Gradle compilation.
  • Consecutive literal edits work reliably via a dual-baseline system that keeps identifiers stable across multiple patches.
  • Hex color values like Color(0xFFFF5722) are correctly parsed and patched at runtime.

Position-Independent Hot Reload

  • Introduces a new pre-compiler transformation stage that runs before the Compose compiler, enabling fully position-independent composable identity.
  • Adding, removing, or reordering composables within a function now preserves existing UI state and groups.
  • The HotSwan compiler plugin ensures stable composable identity regardless of source position, so edits no longer disrupt sibling composables.
  • Inline content blocks (Column {}, Row {}, Box {}) are detected and handled correctly for targeted recomposition.

Targeted Recomposition

  • Body-only changes now trigger significantly more precise recomposition, scoped to the exact function that changed.
  • Preserves remember{} state, animations, and scroll position during body-only edits.

Improved Crash Recovery

  • Structural changes in LazyColumn/LazyGrid items now recover more gracefully with delayed retry phases.
  • SubcomposeLayout subcomposition state is reset before structural reloads to prevent stale data.
  • Class redefinition now runs off the main thread, eliminating the 30-second "Hot Reloading..." stuck state.

2026-04-03

  • Cross-file composable addition: adding new composable functions in one file and calling them from another now works correctly via hot reload.
  • String template hot reload: fixed string template changes (e.g., "Hello $name") not being detected on Kotlin 2.1+ projects.
  • Stable structural hash: body changes in called composables no longer incorrectly trigger structural changes in the caller.
  • Cumulative reload stability: fixed blank screen and crash after 15-20+ consecutive hot reloads.

2026-04-01

  • First reload fix: hot reload now works correctly on the very first edit after starting HotSwan.
  • Hang prevention: fixed rare cases where the plugin could get stuck in "Hot Reloading..." state.
  • Minimum IDE version: now requires IntelliJ 2025.1+ / Android Studio 2025.1+ (Kotlin 2.3.x compatibility).

2026-03-30

  • Smarter crash recovery: structural changes that previously caused app crashes or full rebuilds are now automatically recovered without restarting the app.
  • Animation fix: animateContentSize() and other layout animations now play correctly on every hot reload.
  • Fewer unnecessary rebuilds: fixed cases where simple edits incorrectly triggered a full rebuild instead of hot reload.
  • Broader minSdk support: fixed hot reload failures on projects targeting API 23 (Android 6.0) with default interface methods.
  • Preview Runner: clearer error messages with setup guide link when preview dependency is missing.
  • Improved stability: verified across 60+ real-world editing scenarios including cross-module changes, ViewModel edits, rapid consecutive saves, and complex UI refactoring.

2026-03-27

Structural Hot Reload

  • Dramatically improved structural hot reload: adding remember{}, new composable calls, forEach loops, and Card{} content now preserves navigation and state.
  • Fixed navigation loss when making structural changes like adding mutableStateOf or new @Composable function calls.
  • Partial reload now succeeds even when some internal classes fail to update.
  • Trailing lambda content (e.g., Card{}, Surface{}) now hot reloads correctly.
  • Extreme body replacements with new captured variables are now handled gracefully.

License & Activation

  • New License tab in tool window showing license status and plugin version.
  • Start Free Trial and Manage License dialogs now open directly from the plugin.
  • Improved activation UX with step-by-step guide and redeem code support.

Fixes

  • Preview Runner no longer crashes when preview dependencies are missing.

2026-03-26

Preview Runner

  • Preview Runner now supports @PreviewParameter: provider values are resolved automatically via reflection.
  • Fixed Preview Runner not working on projects with product flavors (NowInAndroid, etc.): package name is now resolved from running process.
  • Fixed Preview Runner showing the same preview regardless of which gutter icon was clicked.

Fixes

  • Fixed Gradle processes failing on systems without system Java: plugin now passes JAVA_HOME from Android Studio's bundled JDK.
  • Removed deprecated IntelliJ API usage (AnActionEvent.createFromDataContext, addBrowseFolderListener).

2026-03-25

Preview Runner

  • Run individual @Preview composables on device via gutter play icon. Component isolation without navigating through the full app.
  • K2 mode compatible: text-based @Preview detection, no Kotlin PSI dependency.
  • Crash recovery: UncaughtExceptionHandler catches mid-composition errors and restarts the preview Activity with error display.

captureAllPreviews Gradle Task

  • New Gradle task automatically captures screenshots of all @Preview functions across the project and generates a browsable HTML catalog.
  • SDK Documentation mode (sdkModeEnabled): extracts KDoc and parameter info from inner composables for rich API documentation.
  • Configuration cache compatible with Property<T> types.
  • HTML catalog features: dark mode default, search, module grouping toggle, fullscreen modal, expand/collapse for large parameter lists.
  • HotSwan branding with favicon and link to hotswan.dev.
  • DSL: hotSwanCompiler { preview { sdkModeEnabled.set(true); renderDelayMs.set(3000L) } }

MCP

  • New tools: hotswan_run_preview and hotswan_capture_previews.

Fixes

  • Fixed performFullRebuild() not returning to WATCHING state, stuck in COMPILING after rebuild completes.
  • Fixed FileChangeWatcher suppression not resetting after reload, causing file changes to be silently ignored.
  • Added 15-second max guard on suppressUntil to prevent stale suppression.

2026-03-25

  • Fixed compile error when non-composable suspend extension functions are present in the same file as composables.
  • Fixed "Cannot run Project.afterEvaluate(Action) when the project is already evaluated" crash in projects using convention plugins.
  • Improved onboarding experience for first-time users.

2026-03-24

  • Hot reload now broadcasts to all connected devices simultaneously. Edit once, see changes on phone, tablet, and emulator at the same time.
  • New chip-based device selector UI replaces the single-device dropdown.
  • Parallel DEX push with per-device error handling and independent reconnection.
  • New Inspector tab in the tool window visualizes the live Composition tree from the running app.
  • Source-Linked Reload Summary: after hot reload, shows which composables in the changed file were recomposed with blast radius statistics.
  • Full Rebuild Diagnostic: when a full rebuild occurs, displays the reason and a tip for avoiding it.
  • Double-click any composable in the Inspector to navigate to its source file and line.
  • Framework composables (remember, Layout, CompositionLocalProvider, etc.) automatically filtered out in Inspector.
  • Fixed lateinit var + isInitialized pattern causing IllegalArgumentException in ViewModels.
  • Fixed app-first workflow: starting HotSwan after the app is already running no longer triggers an unnecessary full rebuild.
  • Fixed stale device serials causing ADB errors after IDE restart.
  • Hot reload log messages now include the target device serial for multi-device clarity.

2026-03-22

  • Fixed device detection on Windows: plugin now correctly resolves adb.exe and uses platform-appropriate lookup commands.

2026-03-22

  • Improved license activation UX: first-time users see "Start Free Trial", returning users see "Activate License".
  • Improved device detection: resolves Android SDK from Android Studio's internal settings with additional platform fallbacks.

2026-03-21

  • Fixed NoSuchMethodError crash on Kotlin 2.3.20+ caused by an internal ABI change in the Kotlin compiler.
  • Compiler plugin is now forward-compatible with Kotlin 2.1.x through 2.3.20+ without recompilation.

2026-03-21

  • Fixed NoSuchMethodError crash on Kotlin 2.3.0 and other versions where an internal IR API was removed.

2026-03-21

  • Fixed build failure on projects with warningsAsErrors=true caused by deprecated generateFunctionKeyMetaClasses Compose compiler flag.
  • Fixed kotlin-reflect not found in Gradle cache startup error on Kotlin 2.x projects (especially KMP).

2026-03-20

  • Fixed hot reload not applying composable argument changes (fontSize, text, color) in library modules.
  • Synced annotation keys with stabilized ordinal-based keys, enabling targeted invalidation in library modules.

2026-03-20

  • Fixed compiler plugin applying full-phase transformation to library modules, which broke remember{} state, animations, and callback references in composables defined in project library modules.
  • Library modules now only receive safe key stabilization without structural changes.
  • Resolves: ProgressBar animations not playing, Coil image loading failures, broken event handlers in library composables.

2026-03-17

  • Adding new lambda expressions (remember, LaunchedEffect, event handlers) to existing composables now hot reloads without full rebuild.
  • Targeted compositional graph invalidation with scope-level resolution for minimal recomposition overhead.
  • Adaptive composition table capacity management for deeply nested layout hierarchies.
  • Extended runtime class transformation pipeline with broader structural mutation support.
  • Improved recovery from nested closure evolution in complex UI trees.

2026-03-15

  • Extension functions, suspend functions, and vararg parameters are now fully supported for hot reload.
  • Functions with more than 8 parameters are now hot reloadable via overflow array packing.
  • ViewModel method isolation: business logic changes in ViewModel classes are instantly hot reloaded without full class redefinition.
  • Data class property addition: adding new properties to data classes no longer triggers a full rebuild on API 30+.
  • ART structural redefinition: method and field additions are handled natively via ART extensions on supported devices.
  • Lambda method index remapping reduces unnecessary full rebuilds when editing lambda expressions.
  • Proactive disposal of paused subcompositions prevents ArrayIndexOutOfBoundsException in LazyColumn, LazyGrid, and LazyStaggeredGrid during structural hot reload.
  • Improved crash guard coverage for structural changes that can trigger delayed scroll crashes.
  • ChangedFlagCleaner now handles isolated function bodies, fixing stale value reads after body only edits.

  • MCP server: AI coding assistants can now trigger hot reload, capture snapshots, and read device logs via MCP protocol.
  • License activation panel: streamlined in plugin license setup with clear activation flow.
  • Snapshot timeline: improved slider controls and gallery layout.

2026-03-12

  • Compiler plugin: stable group key generation eliminates slot table mismatches caused by source level edits.
  • Compiler plugin: granular function level hot reload enables adding or removing composable functions without full rebuild.
  • Compiler plugin: same file call optimization reduces structural changes when composables reference each other.
  • Compiler plugin: automatic detection of value only vs structural edits for optimal state preservation.
  • Improved compatibility with Navigation 3 and other framework level subcompositions.
  • Snapshot panel: compact icon only toolbar for Start/Stop, Clear, and Export actions.
  • Console panel: added Clear button to quickly reset the log view.

2026-03-10

  • Faster reload cycles: skip unnecessary recompilation for unchanged classes.
  • Improved state preservation: body only edits no longer reset remember{} or scroll positions.
  • Better error recovery: reduced ANR risk during hot reload of complex layouts (LazyColumn, Scaffold, etc.).
  • Smarter structural change detection: automatically distinguishes body only vs structural edits for optimal recovery strategy.
  • Compiler plugin: position independent remember{} keys prevent state corruption across reloads.

2026-03-08

  • Instant code reload: save a .kt file and see UI changes on the device in under a second.
  • Resource hot reload: edit strings, colors, drawables, and dimensions without restarting the app.
  • Screenshot snapshot: auto capture device screenshots after each reload with code diff tracking and gallery view.
  • Multi module support with automatic module and build variant detection.
  • State preservation: scroll positions, navigation, and rememberSaveable survive reloads.
  • Auto recovery: detects stale APK or structural changes and rebuilds automatically.
  • Live progress panel with device selector, connection indicator, and log export.
  • Configurable settings under Tools > Compose HotSwan.
  • Keyboard shortcut: Ctrl+Shift+F10.