Comparing similar tools

Kareki focuses on workspace-wide unused code detection and ongoing cleanup in CI.

Feature comparison

✅ Supported (including opt-in features), △ partially supported, — no equivalent feature.

• A ✅ still has analysis limits; for example, kareki excludes operators.
• Enum values are compared separately from declarations and members.
• Dart Code Linter’s public / private member checks require opt-in flags and include enum values. See its CLI .
• Dart Code Linter’s l10n check targets members of Dart classes. The default class-name pattern is I18n$; use --class-pattern AppLocalizations for AppLocalizations. See its configuration .
• Some ciach findings are report-only and cannot be automatically removed. See its README .
• The parameter row checks whether callers supply values. This differs from Dart Code Linter’s unused-in-body check and Dart’s check for private declarations .

Feature details

Unused public declarations and members

Find public classes, functions, fields, and methods that have no recognized use within the analyzed workspace. Kareki reports eligible declarations that cannot be reached from entry points with unused_element. See the analysis example .

Unused public enum values

Check individual enum values, even when the enum type itself is used. For example, if only Status.active is used, Status.archived may be unused. Kareki checks values with unused_element; a reachable Status.values retains every value. See rule evidence .

Public declaration cycles unreachable from entry points

Find public declarations that reference each other but cannot be reached from entry points such as main. A reference within the cycle alone does not make those declarations used in kareki. See analysis differences .

Unused Dart files

Find Dart files that no other scanned file imports, exports, or includes with part, and that are not entry-point files. Kareki’s unused_file checks file references separately from whether the declarations inside are reachable. See rule evidence .

Unused pub dependencies

Find dependencies declared in pubspec.yaml that have no recognized use. Kareki’s unused_pub_dependency also recognizes supported annotation, build-configuration, native-plugin, and asset usage, beyond Dart imports. See dependency usage beyond imports .

Optional public API parameters never supplied by callers

Find optional named or positional parameters for which no scanned caller supplies a value. This can reveal an API option that is never exercised, even when the function body reads the parameter’s default value. Kareki’s unused_parameter_optional does not report parameters with unknown call paths. See optional-argument usage .

Public declarations used only by tests

Find public declarations reachable from test entry points but not production entry points. Kareki’s test_only_used distinguishes test-only use from code with no recognized use at all. See rule evidence .

Report only new findings using a baseline

Save existing findings, then omit matching findings on later runs so CI can report newly introduced issues while cleanup proceeds gradually. Kareki uses --baseline and --write-baseline to load and save that record. See the baseline guide .

Stale exclusions and baseline entries

Find exclusions, suppression comments, and baseline entries that no longer apply, for example because the target file or unused declaration was removed. kareki doctor reports these issues without changing files; uncertain analysis can prevent usage-dependent checks from completing. See doctor’s checks .

Analysis differences

Kareki follows references from entry points, so it can detect public declarations that only reference each other. Generated code, configuration, and dynamic-call handling can still retain them. Ciach’s --transitive detects declarations referenced only by dead code, but not cycles. Dart Code Linter checks whether references exist. See ciach’s documentation and Dart Code Linter’s implementation .

Ciach also distinguishes same-name declarations and collects cross-package references; neither is unique to kareki. See ciach’s implementation and monorepo documentation .

Using the tools together

Kareki leaves unused private declarations and members to standard Dart analysis, adding public API and cross-package checks. Keep dart analyze / flutter analyze for those private-code checks, type checking, and linting. See Dart’s unused-declaration diagnostic .

dependency_validator also covers missing dependencies and incorrect placement in dependencies / dev_dependencies, beyond unused dependencies. See dependency_validator’s documentation .

Speed and false-positive rates have not been benchmarked across these tools. A ✅ does not guarantee safe deletion. Review findings and test changes, especially for published APIs and dynamic calls.

Versions compared

Checked October 10, 2026, against official documentation and source.