Are there any refactoring tools that handle large monorepos without slowing down the editor?

Yes. For large monorepos, the best options are usually tools that do language-aware refactoring with an out-of-process language server or batch/CLI refactors rather than heavy editor plugins that constantly re-index everything.

Good options by ecosystem

TypeScript / JavaScript

• TypeScript Language Server / tsserver
  Built into VS Code and many editors. Handles rename, extract, find references, etc. pretty well in big repos if your tsconfig setup is clean.
• WebStorm / IntelliJ
  Often better than lightweight editors for huge JS/TS monorepos because indexing is strong and refactors are robust.
• Nx / Turborepo-aware tooling
  Not refactoring itself, but helps keep project boundaries and references manageable, which improves refactor performance.

Java / Kotlin

• IntelliJ IDEA
  One of the best for large monorepos. Strong refactoring engine, incremental indexing, generally reliable.
• Eclipse / JetBrains Fleet
  Can work, but IntelliJ is the usual recommendation.

Python

• PyCharm
  Strong refactor support and reasonably good for large codebases.
• Ruff / Pyright
  Not refactoring tools, but they help keep the codebase analyzable and can reduce editor lag.

Go

• gopls
  Very good rename and code navigation performance, even in large repos, if modules are organized well.

Rust

• rust-analyzer
  Generally good, but very large monorepos can still be heavy; workspace splitting helps a lot.

C# / .NET

• Rider / Visual Studio
  Very strong refactoring and good handling of large solutions.

What tends to avoid editor slowdown

• Language servers that index incrementally
• Workspaces split into smaller logical projects
• Monorepo-aware dependency graphs so the editor doesn’t treat everything as one giant project
• CLI refactor scripts for large mechanical changes:
  • sed, ripgrep, comby, codemod, jscodeshift, bowler, rope, ast-grep

Particularly useful batch refactoring tools

If your concern is “don’t freeze the editor,” these are often better for big transformations:

• comby — syntax-aware search/replace across many languages
• ast-grep — AST-based refactors with safer matching
• jscodeshift — JS/TS codemods
• codemod / libcst — Python-friendly structured edits
• rope — Python refactors, though performance varies on huge repos

Practical advice

For huge monorepos, the most important factor is often not the refactoring tool itself but:

1. Split the repo into smaller workspace roots
2. Use project references / module boundaries
3. Exclude generated/vendor/build directories
4. Keep the language server config tight
5. Use batch codemods for broad changes, editor refactors for local changes

If you tell me the language stack and editor you use, I can suggest the fastest refactoring setup for that specific monorepo.