Cline GitHub: Repo, Releases, and How to Contribute

As of 16 July 2026, the official cline/cline repository shows about 64,700 GitHub stars, roughly 6,900 forks, and a public Apache License 2.0. Separately, DataForSEO reports about 880 US monthly searches for the navigational query "cline github." That is a lot of people landing on a monorepo homepage without a guided tour of what to open first, how releases are versioned, or which directory maps to the IDE versus the CLI.

Quotable definition: The Cline GitHub repository hosts the open-source coding agent runtime used by the VS Code extension, JetBrains plugin, CLI, and SDK.

GitHub's own description of the project is short and accurate: "Autonomous coding agent as an SDK, IDE extension, or CLI assistant." The product site and docs back that up. Cline is not a single binary. It is a shared agent core packaged as multiple surfaces, with public docs at docs.cline.bot and community channels linked from the repo (Discord, r/cline, feature-request discussions).

If you only have five minutes on the page, work this list in order:

1. Official repo URL: https://github.com/cline/cline under the cline org, default branch main.
2. What the project contains: TypeScript monorepo with sdk/, apps/cli/, apps/vscode/, root product CHANGELOG, docs tree, and contributing guides.
3. Where docs live: Public site at docs.cline.bot; install guide at Installing Cline; repo docs/ mirrors documentation source.
4. Marketplace vs source: Most users install from the VS Code Marketplace, JetBrains Marketplace, or npm install -g cline. Source builds are for contributors and people who need unreleased changes.
5. License and security: Apache 2.0 in LICENSE. Report security issues through GitHub Security Advisories, not public issues.
6. Community entry points: Discord, r/cline, Feature Requests discussions, and the careers page linked from the README.

That sequence answers the navigational intent behind "cline github" better than scrolling a long marketing README. Stars and forks tell you the project is active and widely watched. They do not tell you which package to install for your editor, or which release tag applies to the CLI on your CI runner.

Treat third-party forks and renamed marketplace clones carefully. The extension ID on the Visual Studio Marketplace is saoudrizwan.claude-dev (historical package name, current product is Cline). The JetBrains plugin is published as plugin ID 28247-cline. When you clone for contribution work, use https://github.com/cline/cline.git and follow the org's CONTRIBUTING.md.

The biggest content gap around Cline GitHub is structural. Search results treat the repo as "the VS Code extension source." Official README index material is clearer: one agent engine, several distribution surfaces, with some pieces still mid-migration.

SDK (sdk/)

The Node.js programmatic surface. Install with npm install @cline/sdk. Docs live under the Cline SDK section on docs.cline.bot. This is the path if you want custom tools, multi-agent orchestration, connectors, or scheduled automations on the same engine that powers the products. Root package.json workspaces include sdk/packages/* and SDK examples.

CLI (apps/cli/)

Terminal UI, headless mode, shell flows, and CI-friendly JSON output. Install path for users is npm install -g cline (nightly: cline@nightly). Platform binaries cover macOS, Linux, and Windows on arm64 and x64 via optional dependencies. The CLI README states that plan/act modes, MCP servers, checkpoints, rules, skills, and provider configuration match the IDE surfaces.

VS Code extension (apps/vscode/, migration in progress)

Marketplace install remains the default for daily use. Source work happens under apps/vscode with bun-based install, proto generation, and F5 debug workflows described in CONTRIBUTING.md. The root README still notes the VS Code extension as "WIP migrating," so expect path names and scripts to evolve; read the latest contributing steps before you build.

JetBrains plugin

Available from the JetBrains Marketplace for IntelliJ IDEA, PyCharm, WebStorm, GoLand, and related IDEs. The official monorepo index states JetBrains plugins are not currently open-sourced. Install and use the published plugin; do not expect a full JetBrains client tree inside cline/cline.

Kanban

Multi-agent task board with worktrees and dependency chains. Shipped as a related product (npm i -g kanban or npx kanban) with source tracked in cline/kanban, not as the primary package under apps/cli.

Docs and governance files

Useful top-level anchors for humans and agents alike:

• README.md for product surfaces and model/provider matrix
• CONTRIBUTING.md for issue-first contribution rules
• CHANGELOG.md for extension-oriented product notes
• CODE_OF_CONDUCT.md, SECURITY.md, LICENSE
• .clinerules/ and project agent config directories for in-repo agent conventions
• docs/ for documentation source consumed by the public docs site

When you are deciding what to clone, match the job to the package:

• Edit code with human approval in an IDE: marketplace extension or plugin first.
• Automate reviews or fixes in CI: CLI headless mode.
• Embed the agent in your own product: SDK.
• Run many parallel agent tasks from a board: Kanban.
• Patch or audit the engine: full monorepo with bun, git-lfs, and the apps you actually touch.

Local disk, Git remotes, and object storage such as S3 remain fine places for source checkout and build artifacts. Those tools do not give a team a shared, permissioned workspace where agent diffs, plan notes, and delivery packages stay queryable after the task ends. For that coordination layer, teams often add a workspace product such as Fast.io next to the git remote rather than treating the laptop clone as the only system of record.

Cline does not publish a single linear version number for every surface. GitHub Releases on cline/cline use separate tag families. Reading that correctly prevents the classic "I upgraded the extension and my CLI is still three weeks behind" mismatch.

Recent public tags (sampled mid-July 2026) fall into clear tracks:

• VS Code / product tags: v4.0.x style releases (for example v4.0.8 on 11 July 2026, v4.0.7 on 9 July 2026).
• CLI tags: cli-v3.0.x style releases, often within a day or two of related work (for example cli-v3.0.42 and cli-v3.0.41 on 16 and 15 July 2026).
• SDK tags: sdk/sdk/v0.0.x style releases (for example sdk/sdk/v0.0.62 on 16 July 2026).

Cadence is high. In a 30-release window around July 2026, CLI tags dominated count, with VS Code v4 tags and SDK tags interleaved. Treat "latest" as track-specific:

• Pin CI to an explicit cli-v* tag or npm version, not "whatever main is today."
• Let the IDE auto-update from the marketplace if you want the polished extension channel, or pin a known good v4.x when your team needs change control.
• Follow SDK changelogs under sdk/ when you build on @cline/sdk, because SDK minor versions can move independently of the marketplace extension.

Practical release hygiene for teams:

1. Subscribe to the GitHub Releases feed for cline/cline if you maintain internal install docs.
2. Record three version fields in your runbooks: extension version, cline --version (or package version), and @cline/sdk version when applicable.
3. Prefer npm's cline@nightly only on non-production machines. Nightly is useful for early testing, not for shared agent pipelines.
4. Read surface-specific CHANGELOG files when the root changelog is silent about CLI or SDK-only fixes.
5. Confirm JetBrains plugin versions from the JetBrains Marketplace page, not from monorepo tags, while that client remains closed source.

High star counts and frequent tags signal an active project. They also mean main can move under you. Contributors should rebase often. Product teams should pin installers. Neither group should assume that "Cline 4" and "Cline CLI 3" share a single release train.

Keep Cline agent output in one shared workspace

Store plans, diffs, and delivery packages where humans and agents both work. Fast.io gives you org-owned workspaces, version history, Intelligence Mode, and an MCP endpoint, starting with a 14-day free trial.

Start 14-Day Trial

Official install docs split the world into four paths: IDE extension, CLI, Kanban, and SDK. Most "cline github" searchers want one of the first two. Building from source is a different job.

Marketplace and package installs (recommended for use)

VS Code family (VS Code, Cursor, Windsurf, VSCodium, Antigravity):

1. Open Extensions (Ctrl/Cmd + Shift + X).
2. Search Cline.
3. Install the Cline extension.
4. Open Cline from the activity bar or Command Palette (Cline: Open In New Tab).
5. Complete provider setup (Cline Provider, ClinePass, or your own model keys).

Windsurf and VSCodium use Open VSX with the same install flow. Marketplace listing: VS Marketplace item saoudrizwan.claude-dev.

JetBrains:

1. Settings → Plugins → Marketplace.
2. Search Cline, install, restart.
3. View → Tool Windows → Cline.
4. Complete provider authorization.

Direct link: JetBrains plugin 28247-cline.

CLI:

Requires Node.js 20+ (22 recommended), then:

npm install -g cline
cline auth
cline

Or pass a one-shot task: cline "your task".

SDK:

mkdir my-agent && cd my-agent
npm init -y
npm install @cline/sdk

Kanban (preview board workflows):

Requires Node.js 18+, then:

npx kanban

Build from the GitHub repository (contributors and advanced users)

Follow the project's CONTRIBUTING.md rather than improvising. Core requirements observed in the official guide:

1. Install git-lfs, then git clone https://github.com/cline/cline.git.
2. Open the project in VS Code.
3. Install bun.
4. For extension work: cd apps/vscode && bun run install:all, then generate protos before first build.
5. Build the SDK package when your surface depends on it: cd sdk && bun run build.
6. Launch with F5 / Start Debugging for an Extension Development Host window.
7. Format and test before PR (bun run format:fix, surface-specific test scripts such as cd apps/vscode && bun run test).

Linux contributor machines need the GUI test libraries listed in CONTRIBUTING.md (for example dbus, libgtk-3-0, xvfb, and related packages) if you run the VS Code extension test suite.

When source install is worth it

• You are fixing a bug or landing a feature with maintainer approval.
• You need to verify a PR branch against your own codebase.
• You are auditing how tools, approvals, or MCP wiring work in the open code.

When it is not

• You only want Cline in Cursor or VS Code today. Use the marketplace.
• You need a stable CI agent. Pin a published CLI version from npm.
• You want the JetBrains experience. Use the published plugin; the client is not fully open-sourced in this monorepo.

After Cline writes or rewrites files, those changes usually live in a local git worktree until you commit or hand them off. Some teams keep that entirely on local disk or push straight to GitHub. Others stage intermediate plans, logs, and client deliverables in shared cloud storage such as Google Drive or Dropbox, then lose search and version clarity. A better middle path for agentic teams is a shared org workspace with per-file version history, granular permissions, and agent-accessible MCP endpoints. Fast.io is built for that layer: humans use the UI, agents use Streamable HTTP at /mcp (legacy SSE at /sse), and ownership can transfer from agent-built structure to a human owner while admin access remains available. Plans start at Starter $29/mo, Business $99/mo, and Growth $299/mo, each with a 14-day free trial that requires a credit card.

Cline's contribution policy is explicit and easy to miss if you only skim the stars counter. From the official CONTRIBUTING.md:

• All members must follow the Code of Conduct.
• Bug reports go through the issue templates after a duplicate search.
• Security vulnerabilities go through GitHub Security Advisories, never public issues.
• Features and larger contributions start with a GitHub Issue. Check Feature Requests discussions first, open a request if needed, and wait for core maintainer approval before implementing.
• PRs without approved issues may be closed.
• Small bug fixes, typo corrections, minor wording improvements, and simple type fixes that do not change behavior are the exception to the issue-first rule.

That policy is friendlier than it sounds. It protects reviewers on a high-velocity monorepo. With thousands of open issues historically and a very active release train, unscoped drive-by PRs do not scale.

Picking work

Look for labels such as good first issue and help wanted on cline/cline issues. Documentation improvements under /docs are also welcome. As of this writing, only a small number of open issues carried the good first issue label, so treat the label as a curated queue, not a large backlog of easy tickets.

PR quality bar

Official guidance asks contributors to:

• Keep each PR focused on a single feature or bug fix.
• Split large changes into smaller, reviewable PRs and commits.
• Run lint and format checks (bun run lint, bun run format / format:fix depending on surface).
• Add or update tests for behavior changes.
• Pass CI, which enforces linting and formatting.

Discord's #contributors channel is the social on-ramp if you want pairing help before you open a PR. Paid roles, if you want them, are linked from the README careers page at cline.bot.

A sane first-contribution path

1. Star and watch the repo only if you actually want notification noise; otherwise just bookmark Releases and Discussions.
2. Reproduce a small bug or pick an approved issue.
3. Comment on the issue so maintainers know it is claimed.
4. Fork, branch from current main, keep the diff narrow.
5. Run the relevant tests for apps/vscode, CLI, or SDK packages you touched.
6. Open the PR with a link to the approved issue and a short reproduction or screenshot for UI work.

If your goal is not code contribution but operational use, you do not need a fork at all. Install from marketplace or npm, keep .clinerules in your application repos, and store long-lived agent outputs where the rest of the team can find them. Git remains the source of truth for source. Shared workspaces remain the better home for plans, research dumps, client packages, and multi-agent intermediate files that should not clog pull requests.

Cline is strong at local action: reading a repo, running commands, editing files, and (with approval) iterating until tests pass. The weak point for multi-person teams is rarely the agent loop. It is everything that happens after the agent stops.

Common patterns and their tradeoffs:

• Local only: Fast, private, fragile. Laptop dies, context dies.
• Git remotes only: Excellent for source. Poor fit for bulky intermediates, unreviewed dumps, or non-code deliverables you do not want on main.
• Generic drives (Google Drive, Dropbox, Box, OneDrive): Familiar sharing, weak agent APIs, weak semantic search over agent history.
• Object storage (S3 and peers): Great for bulk artifacts, more work to make human review and permissions pleasant.

Fast.io sits in the workspace layer between agent tooling and long-term team access. Relevant capabilities for Cline users:

• Org-owned workspaces with granular permissions at org, workspace, folder, and file levels
• Per-file version history so concurrent agent and human edits remain recoverable
• Intelligence Mode for auto-indexing and hybrid search (full-text, semantic, metadata-value) when you need to ask questions with citations
• Consolidated MCP tools over Streamable HTTP (/mcp) and legacy SSE (/sse) so agents can work the same files humans browse
• Branded shares for client handoff, append-only audit log for sensitive work, webhooks for reactive automation
• Ownership transfer so an agent can scaffold structure and a human can take the org forward without losing admin continuity

Example workflow many teams adopt:

1. Run Cline against a git checkout for implementation.
2. Upload plans, eval notes, and delivery zips to a Fast.io workspace (or pull them in via cloud import from Drive/Dropbox/OneDrive/Box when the files already live there).
3. Enable Intelligence on the workspace so later questions about "what did the agent change last week?" do not depend on chat scrollback.
4. Share a branded link with reviewers, or keep permissions internal until the PR merges.
5. If an automation agent created the workspace scaffolding, transfer ownership to the human lead and keep agent admin as needed.

Cline stays the coding agent. Git stays the source control system. Fast.io is the shared intelligent workspace where agent output becomes team output. Start with the 14-day free trial if you want to test that split on a real project.