Catch Jetpack Compose mistakes as you type — 37 best-practice rules from the Compose Rules guidelines, surfaced live in Android Studio & IntelliJ IDEA with inline highlights, gutter icons, and one-click fixes.

The Compose Rules catch the subtle mistakes that hurt Compose code — missing Modifier parameters, un-remembered state, unstable collections, reused modifiers, and dozens more. ComposeGuard brings those checks into the editor, so you fix them while the code is still fresh instead of discovering them in a build log or a code review.

• ⚡ Instant — analysis runs as you type; no build, no Gradle task, no CI round-trip.
• 🎯 Accurate — rules are PSI-based and tuned to avoid false positives on valid patterns (overrides, scoped slots, mutually-exclusive branches, run-once effects, …).
• 🛠 Actionable — most violations come with a quick fix (Alt+Enter) and a detailed explanation of why it matters.
• 🎚 Configurable — enable/disable any rule or whole category, or suppress per declaration.

• Features
• Installation
• Quick Start
• Suppressing Rules
• Rule Reference
• Statistics Dashboard
• Configuration
• Requirements & Compatibility
• Contributing
• Credits
• License

• Real-time highlighting — violations appear as colored underlines while you edit.
• Gutter icons — a color-coded dot per @Composable summarizes its status at a glance:
  • 🔴 Error    🟠 Warning    ⚪ Weak warning    🔵 Info
• Inline hints — compact badges next to function names show rule violations.
• Hover tooltips — every violation explains the problem, the reasoning, and the fix.
• Quick fixes — rename, add a modifier parameter, wrap in remember, switch to a type-specific state, make a preview private, swap to an immutable collection, and more.
• 37 rules across 6 categories — see the full Rule Reference.

1. Open Android Studio or IntelliJ IDEA.
2. Go to Settings → Plugins → Marketplace.
3. Search for ComposeGuard.
4. Click Install and restart when prompted.

Or install directly from the JetBrains Marketplace.

Once installed, ComposeGuard automatically analyzes any Kotlin file containing @Composable functions — no configuration required. Here are a few things it catches:

// 🟠 Naming: Unit-returning composables should be PascalCase
@Composable
fun userCard(user: User) { }              // → rename to "UserCard"

// 🟠 Modifier: public UI composables should expose a Modifier
@Composable
fun ProductCard(product: Product) {       // → add `modifier: Modifier = Modifier`
    Column { Text(product.name) }
}

// 🔴 State: state must be remembered
@Composable
fun Counter() {
    val count = mutableStateOf(0)         // → wrap in remember { }
}

// 🟠 Stricter: prefer stable collections
@Composable
fun ItemList(items: List<Item>) { }       // → use ImmutableList<Item>

Hover any highlight for the full explanation, or press Alt+Enter to apply a fix.

To intentionally allow a violation, annotate the declaration with @Suppress using the rule id (the same id shown in the warning, e.g. ModifierRequired). The quick fix can insert this for you:

@Suppress("ModifierRequired")
@Composable
fun SplashLogo() {
    Image(painterResource(R.drawable.logo), contentDescription = null)
}

// Multiple rules at once:
@Suppress("ModifierRequired", "ComposableNaming")
@Composable
fun splash() { /* ... */ }

Suppression works at the function, property, or class level. To turn rules off project-wide instead, use Configuration.

ComposeGuard ships 37 rules based on the Compose Rules guidelines. Severity legend: 🔴 Error · 🟠 Warning · ⚪ Weak warning · 🔵 Info.

Suppress any rule with @Suppress("<RuleId>"), or toggle it in Settings → Tools → ComposeGuard.

ComposeGuard includes a tool window that tracks rule violations across your project.

• Real-time statistics — violation counts update as you code.
• Category breakdown — see violations grouped by rule category.
• Rule-level details — drill into specific rules.
• Project overview — track overall code-quality trends.

Open it from View → Tool Windows → ComposeGuard Statistics.

Configure ComposeGuard at Settings → Tools → ComposeGuard.

• Enable ComposeGuard — master toggle for the whole plugin.
• Display options — toggle gutter icons and inlay hints.
• Rule configuration — enable/disable individual rules or entire categories.

Adding the plugin to a large legacy project? Roll it out gradually instead of facing every warning at once:

1. Start with the Stricter category off (Material2Usage, UnstableCollections).
2. Enable categories one at a time as you refactor — the category checkbox toggles the whole group.
3. Use @Suppress("<RuleId>") for individual, intentional exceptions.

• IntelliJ IDEA 2024.2+ or Android Studio Ladybug (2024.2)+
• The bundled Kotlin plugin (enabled by default)

Contributions are welcome — issues and pull requests both.

1. Fork the repository.
2. Create a feature branch: git checkout -b feature/amazing-feature.
3. Make your change and add tests (./gradlew :compose-guard:test).
4. Commit and push, then open a Pull Request.

Built on the excellent Compose Rules guidelines by Nacho Lopez (mrmans0n).

Designed and developed by 2025 androidpoet (Ranbir Singh)

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

   http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

Made with ❤️ by androidpoet