Skip to content
RuleSellBeta
Sign up

Comparison

Cline vs Roo Code (May 2026): Fork Lineage and Rule Portability

Cline wins on original ecosystem and Apache-2.0 lineage. Roo Code wins on custom modes and 30% token savings via apply_diff. Rules are portable across both forks. Honest decision guide.

Who wins at what

Original-ecosystem ubiquity (VS Code, JetBrains, etc.)
Cline
Custom modes for role-based work
Roo Code
Apache-2.0 lineage and community size
Cline
Token efficiency via apply_diff
Roo Code
.clinerules format ownership
Cline
Marketplace-installable custom modes
Roo Code
Rule portability between both
Tied (same .clinerules format works)
Total install base
Cline (5M+ across editors)

Cline is the original. Roo Code is the fork that added custom modes. Kilo Code is the fork-of-fork that added orchestrator mode and 500+ models. All three read the same .clinerules folder format — which means the choice is genuinely about runtime preference, not about which ecosystem you're locked into.

This page picks winners by dimension and explains the fork story honestly.

Who wins at what

Cline wins on original-ecosystem ubiquity (5M+ installs across six editors), Apache-2.0 lineage, community size, and ownership of the .clinerules format itself. Roo Code wins on custom modes (its defining feature), token efficiency via apply_diff, and marketplace-installable role-based agent configurations. Rule portability is tied — both read the same format.

The "which is better" question collapses into "do you want custom modes or not?"

What each one actually is

Cline (apache-2.0, github.com/cline/cline) is a VS Code extension (also available for JetBrains, Cursor, Windsurf, Zed, Neovim) that runs an autonomous coding agent. It reads .clinerules — originally a single file, now a folder of .md files with optional YAML frontmatter for conditional activation. Plan mode and act mode are the two built-in modes. Per cline.bot/blog/5m-installs, 5M+ total installs as of early 2026. Roo Code (apache-2.0, github.com/RooCodeInc/Roo-Code) is a Cline fork that added custom modes — a system where you define named modes in a .roomodes YAML file with their own role definitions, tool permissions, and rule folders. Roo Code claims ~1.5M users and ships with marketplace-installable modes.

Where Cline wins

Original-ecosystem ubiquity. 5M+ installs across six editors per cline.bot is a real distribution advantage. If you're building a tool, plugin, or rule pack and want maximum reach, Cline's footprint is bigger. The downstream ecosystem (VS Code extensions, JetBrains plugins, etc.) is mature. Apache-2.0 lineage and stability. Cline is the upstream. When the format changes, Cline drives it. Roo Code and Kilo Code follow. If you want to bet on the most stable, longest-supported runtime, Cline is it — forks come and go; the upstream tends to persist. Ownership of .clinerules as a format. The .clinerules folder pattern with YAML frontmatter paths: globs is Cline's. Roo Code reads it; Kilo Code reads it. Cline defines the spec. For documentation and authority on "how should a .clinerules file look," Cline's docs.cline.bot/customization/cline-rules is canonical. Community size. GitHub issues, Discord, Reddit r/cline, Stack Overflow tags — Cline has the active community. Roo Code's community is smaller and partly overlapping (developers contribute to both). For "I have a weird problem and need help fast," Cline's community is broader. Plan/act mode polish. Cline's plan-then-act loop is well-tuned. Plan mode produces a plan; you approve; act mode executes. Simple, predictable. Roo Code has this too but its custom-modes layer adds complexity Cline avoids.

Where Roo Code wins

Custom modes. This is the headline feature. Define a security-audit mode with its own role definition, restricted tool set, and rule folder. Define a docs-writing mode that can only edit .md files. Define a React-refactor mode tuned for TSX work. Each mode is a focused agent with explicit boundaries. Cline has plan/act; Roo Code lets you build as many modes as your team needs. Token efficiency via apply_diff. Roo Code's apply_diff tool sends edit diffs instead of full file rewrites. On equivalent refactor tasks, qodo.ai's benchmark reports ~30% token savings. The number is reproducible on edit-shaped work. Cline's diff-based edits work but the default behavior differs. Marketplace-installable modes. Roo Code ships a marketplace where you can install custom modes one-click. jtgsystems/Custom-Modes-Roo-Code is the de-facto community gallery. For teams that want pre-built role agents (security reviewer, accessibility auditor, docs writer), Roo Code is the only choice between these two. Cleaner separation of role from rules. A Roo Code mode is "a role + a rule set + a tool permission set." This decomposition is cleaner than putting everything in CLAUDE.md or .clinerules. For complex multi-role workflows (where the same agent should behave differently in different contexts), Roo Code's primitives are better-fit. Smaller, more opinionated community. Counter-intuitive advantage: Roo Code's smaller community means more opinionated defaults and faster iteration on the custom-modes feature. The downside is fewer Stack Overflow answers; the upside is the maintainers move quickly.

Where the comparison gets uncomfortable

The fork question is real. Apache-2.0 makes forks legal, but they fragment the ecosystem. A rule that works in Cline today might break in Roo Code six months from now if the formats diverge. So far, Roo Code has stayed close to Cline's .clinerules format — but the divergence pressure exists, and Kilo Code is already adding modes-related features that don't exist in either. Roo Code's custom modes can be overkill. For solo developers or small projects, plan/act mode is enough. The custom-modes layer is real cognitive overhead — defining mode YAMLs, separating rule folders by mode, debugging which mode triggered when. If you don't have role-based workflows, Cline is simpler. Both have the same security profile. Neither runs security scans on community .clinerules or custom modes. The same prompt-injection risks that affect Cursor rules (Rules File Backdoor) apply here. Audit before you install. Both lag Claude Code on hooks and verification. Neither has a Stop hook or a PreToolUse hook equivalent to Claude Code's. For verification-first workflows (HN 46934254), Cline and Roo Code are weaker. The mode system in Roo Code partially compensates by letting you define a "verifier" mode, but the deterministic hook lifecycle isn't there.

When to use both together (or pick one and Kilo)

Most teams pick one runtime and stick with it. The "use both" pattern is uncommon and adds friction. The more interesting "use both" is pairing one of these with a CLI agent:

  • Cline (or Roo Code) + Claude Code — Cline for in-editor agentic work, Claude Code for terminal-native long-horizon runs.
  • Cline + AGENTS.md — Cline supports AGENTS.md per the feature request issue #5033 discussion; AGENTS.md is becoming the cross-tool source of truth.
  • The same .clinerules pack working across Cline, Roo Code, and Kilo Code — author once, install across three runtimes.
Whichever runtime you pick, RuleSell's catalog ships .clinerules packs tagged for portability across the Cline lineage. A single rule pack works in all three. Buy once; deploy where your team's tool fits.

Where this comparison fails / what we don't know

We didn't benchmark the two runtimes on a controlled task. The 30% token-savings figure comes from one published benchmark on edit-shaped work; it doesn't generalize to all workloads. The user count claims (Cline 5M, Roo Code 1.5M) come from the projects themselves and haven't been independently verified.

We also don't know how Kilo Code's $8M seed and orchestrator mode reshape the lineage. If Kilo's features get pulled back into Cline or Roo Code, the fork pressure eases. If Kilo continues to diverge, the .clinerules portability story weakens. Watch the next 6-12 months.

What to read next

Sources

Frequently asked

Are .clinerules portable between Cline and Roo Code?
Yes. Roo Code is a fork of Cline and reads the same .clinerules folder format (with optional YAML frontmatter and paths: globs). The same rule file works in both, and also in Kilo Code (the fork-of-fork). This is a major distribution multiplier — a single rule pack serves the entire Cline lineage. Source: [Roo Code GitHub](https://github.com/RooCodeInc/Roo-Code), [Kilo Code GitHub](https://github.com/Kilo-Org/kilocode/).
What are Roo Code's custom modes?
Roo Code's defining feature: define a .roomodes file (YAML) or settings/custom_modes.yaml with a customModes: array. Each mode has a slug, a roleDefinition (system prompt fragment), and groups (tool permissions). Mode-specific instructions live in .roo/rules-{slug}/. This lets you have a 'security audit' mode, a 'docs writing' mode, a 'React refactor' mode — each with its own prompt and toolset. Cline has plan/act modes but they're not customizable in the same way. Docs: [docs.roocode.com/features/custom-modes](https://docs.roocode.com/features/custom-modes).
Which one has more users?
Cline has 5M+ installs across VS Code, JetBrains, Cursor, Windsurf, Zed, and Neovim per [cline.bot/blog/5m-installs](https://cline.bot/blog/5m-installs-1m-open-source-grant-program). Roo Code claims ~1.5M users. Cline is the broader ecosystem; Roo Code is the more opinionated fork.
Why fork Cline instead of contributing to it?
Roo Code's custom-modes feature was a substantial architectural addition; doing it as a fork let the team iterate without coordination overhead. The Apache-2.0 license made the fork legal and Cline-friendly. The pattern is now repeating with Kilo Code (a fork of Roo Code), which raised $8M seed and added orchestrator mode and 500+ model support.
Is Roo Code really 30% more token-efficient than Cline?
The 30% figure comes from Roo Code's apply_diff tool, which sends edit diffs instead of full file rewrites. On equivalent refactoring tasks, this saves tokens. The number is reproducible on edit-shaped work but doesn't generalize to all workloads. Source: [qodo.ai blog](https://www.qodo.ai/blog/roo-code-vs-cline/) and Roo Code docs. Cline can also use diff-based edits but defaults differ.
Should I use Cline, Roo Code, or Kilo Code?
Cline for the broadest stable ecosystem. Roo Code if you want custom modes for role-based work. Kilo Code if you want the orchestrator mode plus 500+ models — but it's newer and less battle-tested. The honest framing: all three read .clinerules, so a rule pack you author works in all three. Pick the runtime that fits your workflow; the rule content is portable.

Related topics