Last updated: May 11, 2026 · Shutdown date: May 15, 2026
Roo Code is shutting down on May 15, 2026 — in four days from this post. The VS Code extension, Roo Code Cloud, and Roo Code Router are all being archived. The team is pivoting to Roomote, a cloud-based agent that operates outside the IDE entirely.
If you are a Roo Code user searching for what to do with your .roorules and .roo/rules/ configuration, this guide covers where that config goes, which tools can use it, and what to do before the cutoff.
On April 21, 2026, Roo Code CEO Matt Rubens announced the shutdown. The project had reached 3 million installs — a significant milestone — but the team decided to go all-in on a different model of AI-assisted development: cloud agents that take tasks end-to-end without requiring the developer to stay in the loop inside an editor.
Roo Code's own official recommendation for extension users:
"If you want a model-agnostic open-source extension, we recommend Cline. They've incorporated much of what we built and are excited to welcome Roo Code users."
Cline's response was public acknowledgment and welcome: the Cline team noted that Roo Code "contributed to our community more than any other fork."
Kilo Code — a Roo fork — published an official migration guide the same week and went GA on April 2.
Timeline:
The archived extension will continue to function after May 15 — the binary does not self-destruct. But no bug fixes, no model compatibility updates, and no new features are coming. In a space where model APIs change monthly, a frozen extension has a short useful life.
Roo Code had a layered rules system with four file locations, loaded in order from highest to lowest priority:
Global rules — ~/.roo/rules/ directory
Applied across all your projects on the machine. Files inside are read recursively and appended alphabetically to the system prompt.
Workspace rules — .roo/rules/ directory in your project root (preferred) or .roorules file (fallback)
Project-specific rules committed to the repository. The directory method was preferred over the single-file method. If .roo/rules/ existed but was empty, Roo Code fell back to .roorules.
Mode-specific rules — .roo/rules-{modeSlug}/ directory or .roorules-{modeSlug} file
Rules that applied only when a specific mode was active. For example, .roo/rules-code/ applied only in Code mode, .roo/rules-architect/ only in Architect mode.
Custom mode files — .roomodes (JSON or YAML)
Defined custom modes with their own role definitions, tool access, and rule file paths.
All levels were merged at runtime. Mode-specific rules loaded before general rules within each scope.
Cline is the upstream project that Roo Code originally forked from. It is MIT-licensed, model-agnostic, and actively maintained. Roo Code users migrating to Cline have the highest philosophical continuity — many of the patterns Roo introduced (diff-based edits, MCP support, plan/act mode) have been incorporated into Cline.
Rules migration: .roorules → .clinerules
The mapping is direct. Rename .roorules to .clinerules. The content format is the same markdown — Cline reads it into the system prompt exactly as Roo Code did.
For directory-based rules (.roo/rules/), consolidate the files into a single .clinerules file or use Cline's rules directory if your version supports it. The substance of the rules transfers without modification — build commands, coding standards, forbidden patterns, definition of done.
For the configuration guide, see Cline Rules.
What you lose: Custom modes with distinct role definitions. Cline has plan/act mode but not the full Architect/Code/Debug/Orchestrator mode split that Roo Code had. If your workflow depended heavily on mode-specific rules with different tool access, you will need to flatten them into a single rules file or replicate the behavior through system prompt instructions.
What you gain: Active development, model compatibility updates, and the largest open-source VS Code AI extension community.
Kilo Code started as a Roo Code fork and shares real git history with it. The Kilo team rebuilt the extension on OpenCode server and went GA on April 2, 2026. They published an official Roo-to-Kilo migration guide the same week Roo announced its shutdown.
The new Kilo architecture changed four things that Roo Code users will feel:
read/edit/browser/command/mcp groups no longer exist as such. Kilo uses a different permissions model.kilo.jsonc replaces custom mode config. Project configuration now lives in kilo.jsonc, shared across CLI, VS Code, and Cloud Agents.The Kilo migration is closer to a one-click affair than the Cline migration if your workflow was standard. Your .roorules content carries over; the structural configuration (modes, tool groups) requires remapping.
Best for: Roo Code users who want to stay as close as possible to the original Roo Code feature set, especially Orchestrator mode and the multi-agent architecture.
Continue is a mature, MIT-licensed open-source extension that supports VS Code and JetBrains. It does not replicate Roo Code's agentic loop or custom modes, but it handles autocomplete, chat, and codebase-aware assistance with full local model support via Ollama.
For teams whose Roo Code usage was primarily context-aware chat and autocomplete rather than autonomous multi-file agent tasks, Continue is the lowest-friction migration. No mode remapping, no complex configuration — point it at your models and continue working.
For configuration, see Continue.dev Rules.
Best for: Teams using Roo Code primarily for chat and completion rather than autonomous agent tasks.
| Roo Code | Cline equivalent | Kilo Code equivalent |
|---|---|---|
.roorules |
.clinerules |
rules section in kilo.jsonc |
.roo/rules/ directory |
.clinerules (merged) |
kilo.jsonc rules |
.roo/rules-code/ |
single .clinerules |
mode config in kilo.jsonc |
.roomodes |
not directly equivalent | kilo.jsonc agents |
~/.roo/rules/ global |
global .clinerules |
global Kilo config |
The content inside your rule files — build commands, coding standards, architecture notes, forbidden patterns — transfers to any of these tools without modification. The structure changes; the substance does not.
Roomote is the Roo Code team's next product, not a drop-in replacement for the extension. It is a cloud agent that takes a prompt and executes tasks end-to-end — integrating with Slack, GitHub, and Linear — without requiring you to stay in an IDE.
If you used Roo Code primarily as an in-editor assistant and want to continue that workflow, Roomote is not the answer. It is a different paradigm: async task delegation rather than synchronous pair programming.
If you are interested in exactly that shift — delegating tasks to an agent while you do something else — see the GitHub Copilot Coding Agent guide for comparison with a more established cloud agent approach.
.roorules, .roo/rules/, .roomodes, and any global ~/.roo/rules/ files to a safe location.roorules to .clinerules for Cline, or follow the Kilo migration guide for Kilo Code.clinerules configuration reference