Skip to main content
fallow dupes finds duplicated code blocks across your entire codebase. jscpd v5 is faster for raw duplication scanning on the current README benchmark fixtures; fallow’s advantage is running duplication inside the same audit flow as dead code, dependency, complexity, and architecture checks. 
fallow dupes

​
Why built-in duplication matters

Most dead-code analysis tools stop at finding unused exports and unreachable files. Fallow goes further: it includes duplication detection in the same binary, using the same module graph. This means you can cross-reference dead code with duplication in a single pass. When you run fallow dead-code --include-dupes, fallow identifies code blocks that are both duplicated and unused. These are the highest-value cleanup targets: removing them eliminates dead code and reduces duplication simultaneously. Running duplication analysis alongside dead-code detection also means:
  • One tool, one config, one CI step: No need to install and configure a separate duplication detector
  • Shared file discovery: The same ignore patterns, entry points, and workspace config apply to both analyses
  • Cross-analysis insights: Clone families that span unused files are flagged as combined findings
  • Consistent output formats: JSON, SARIF, markdown, compact, and CodeClimate output work the same way for duplication as for dead code

​
Detection modes

Exact token-for-token clones only. No normalization is applied; the code must be character-identical after tokenization.
fallow dupes --mode strict
Best for finding exact copy-paste where nothing was changed.
Start with mild mode (default). Upgrade to semantic when you want to catch clones with renamed variables.
Here’s what typical output looks like:
$ fallow dupes
● Duplicates (3 clone groups)

     57 lines  2 instances
    src/components/Calendar/CalendarMonth.stories.tsx:597-653
    src/components/Calendar/CalendarYear.stories.tsx:818-874

     42 lines  3 instances
    src/features/forecasting/server/procedures/analytics.ts:141-181
    src/features/forecasting/server/procedures/cashflow.ts:153-194
    src/features/forecasting/server/procedures/income.ts:590-631

  Identical code blocks detected via suffix-array analysis, https://docs.fallow.tools/explanations/duplication#clone-groups

✓ 27,255 lines (19.4%) duplicated across 398 files (0.23s)
In semantic mode, fallow also reports renamed identifiers:
$ fallow dupes --mode semantic
● Duplicates (2 clone groups)

    196 lines  2 instances
    src/lib/dutch-holidays.ts:193-388
    src/lib/dutch-holidays.ts:389-584
    Renamed: holidays2024→holidays2025, year2024→year2025

     42 lines  3 instances
    src/features/forecasting/server/procedures/analytics.ts:141-181
    src/features/forecasting/server/procedures/cashflow.ts:153-194
    src/features/forecasting/server/procedures/income.ts:590-631
    Renamed: analyticsData→cashflowData→incomeData

  Identical code blocks detected via suffix-array analysis, https://docs.fallow.tools/explanations/duplication#clone-groups

✗ 94,457 lines (67.2%) duplicated across 775 files (3.74s)

​
Thresholds and limits

fallow dupes --min-tokens 50        # Minimum tokens per clone (default: 50)
fallow dupes --min-lines 5          # Minimum lines per clone (default: 5)
fallow dupes --min-occurrences 3    # Only report clones repeated 3+ times (default: 2)
fallow dupes --threshold 5          # Fail if duplication exceeds 5%
fallow dupes --skip-local           # Only cross-directory duplicates

​
Minimum occurrences

By default fallow reports every duplicated pair (minOccurrences: 2). If you follow the “rule of three” and only want to refactor logic once it appears in three or more places, raise the threshold: 
{
  "duplicates": {
    "minOccurrences": 3
  }
}
Values below 2 are rejected, since a single occurrence is not a duplicate. Raising this skips context-sensitive pairs and focuses on widespread copy-paste worth abstracting. The VS Code extension exposes the same control as the fallow.duplication.minOccurrences setting.

​
Clone families

Clone groups sharing the same file set are grouped into clone families with refactoring suggestions:
  • Extract function: clones are in the same file
  • Extract module: clones span multiple files

​
Cross-language detection

Compare TypeScript and JavaScript files by stripping type annotations: 
fallow dupes --cross-language
Fallow normalizes .ts files to their .js equivalent for comparison. This catches clones where one copy was converted from TypeScript to JavaScript or vice versa.

​
Ignoring imports

Files with the same module wiring are a structural property of well-formatted code, not copy-paste, so that wiring is stripped from the token stream by default. This covers ES imports, re-export declarations, and top-level static require() binding declarations. To count module wiring as clone candidates again, opt out on the command line: 
fallow dupes --no-ignore-imports
Or set it permanently in config: 
{
  "duplicates": {
    "ignoreImports": false
  }
}
Runtime code, local exports, side-effect require() calls, nested require() calls, dynamic require arguments, and mixed declarations are still counted.

​
Incremental analysis

Only check duplication in files changed since a git ref: 
fallow dupes --changed-since main
Useful in CI to only report new duplication introduced in a pull request.

​
Baseline comparison

Adopt duplication limits incrementally: 
# Save current duplication as baseline
fallow dupes --save-baseline fallow-baselines/dupes.json

# Fail only on new duplication
fallow dupes --baseline fallow-baselines/dupes.json

​
Debugging

Trace all clones of a specific code location: 
fallow dupes --trace src/utils.ts:42

​
Benchmarks vs jscpd

Cold runs (no cache) so each tool works from scratch. Fastest tool per row in bold.
ProjectFilesfallowjscpdFaster
astro2,859549ms189msjscpd 2.9x
fastify28690ms64msjscpd 1.4x
next.js20,55212.66s861msjscpd 14.7x
preact24458ms49msjscpd 1.2x
TanStack/query901133ms96msjscpd 1.4x
svelte3,337317ms172msjscpd 1.8x
TypeScript38,14613.45s4.58sjscpd 2.9x
vite1,420174ms74msjscpd 2.3x
vue/core522109ms78msjscpd 1.4x
zod17454ms53msjscpd 1.0x
jscpd’s Rust rewrite (v5) is faster than fallow for raw duplication scanning across these projects. Fallow’s advantage is running duplication inside the same single audit pass as dead code, dependency, complexity, CSS, framework, and security checks, not raw scan speed. Fallow uses a with for clone detection, avoiding quadratic pairwise comparison.

​
See also

CLI: dupes

Full reference for the fallow dupes command and its flags.

Configuration

Set default duplication thresholds and modes in your config file.

Migrating from jscpd

Replace jscpd with fallow in your project.