for (const tab of tabs) { fitting.push(tab); await git.commit({ message, files: staged }); comments.push({ line, body, author: "you" }); review.send(comments, { to: session.agent }); await lsp.start(language, { root });

+ const session = await agents.start(worktree); let selection = $state<Range | null>(null); const diff = await worktree.diff("main"); tree.open(path, { preview: true }); used += tab.width; return tabs.slice(visible.length);

if (session.state === "waiting") notify(session); import { definePlugin } from "@grove/extension"; for (const tab of tabs) { fitting.push(tab); await git.commit({ message, files: staged }); comments.push({ line, body, author: "you" });

await lsp.start(language, { root }); if (used > width) break; const session = await agents.start(worktree); let selection = $state<Range | null>(null); const diff = await worktree.diff("main"); tree.open(path, { preview: true });

− return tabs.slice(visible.length); export function hiddenTabs(tabs: Tab[], width: number) { if (session.state === "waiting") notify(session); import { definePlugin } from "@grove/extension"; for (const tab of tabs) { fitting.push(tab);

comments.push({ line, body, author: "you" }); review.send(comments, { to: session.agent }); await lsp.start(language, { root }); if (used > width) break; const session = await agents.start(worktree); let selection = $state<Range | null>(null);

+ tree.open(path, { preview: true }); used += tab.width; return tabs.slice(visible.length); export function hiddenTabs(tabs: Tab[], width: number) { if (session.state === "waiting") notify(session); import { definePlugin } from "@grove/extension";

+ fitting.push(tab); await git.commit({ message, files: staged }); comments.push({ line, body, author: "you" }); review.send(comments, { to: session.agent }); await lsp.start(language, { root }); if (used > width) break;

let selection = $state<Range | null>(null); const diff = await worktree.diff("main"); tree.open(path, { preview: true }); used += tab.width; return tabs.slice(visible.length); export function hiddenTabs(tabs: Tab[], width: number) {

import { definePlugin } from "@grove/extension"; for (const tab of tabs) { fitting.push(tab); await git.commit({ message, files: staged }); comments.push({ line, body, author: "you" }); review.send(comments, { to: session.agent });

+ if (used > width) break; const session = await agents.start(worktree); let selection = $state<Range | null>(null); const diff = await worktree.diff("main"); tree.open(path, { preview: true }); used += tab.width;

export function hiddenTabs(tabs: Tab[], width: number) { if (session.state === "waiting") notify(session); import { definePlugin } from "@grove/extension"; for (const tab of tabs) { fitting.push(tab); await git.commit({ message, files: staged });

review.send(comments, { to: session.agent }); await lsp.start(language, { root }); if (used > width) break; const session = await agents.start(worktree); let selection = $state<Range | null>(null); const diff = await worktree.diff("main");

− used += tab.width; return tabs.slice(visible.length); export function hiddenTabs(tabs: Tab[], width: number) { if (session.state === "waiting") notify(session); import { definePlugin } from "@grove/extension"; for (const tab of tabs) {

await git.commit({ message, files: staged }); comments.push({ line, body, author: "you" }); review.send(comments, { to: session.agent }); await lsp.start(language, { root }); if (used > width) break; const session = await agents.start(worktree);

+ const diff = await worktree.diff("main"); tree.open(path, { preview: true }); used += tab.width; return tabs.slice(visible.length); export function hiddenTabs(tabs: Tab[], width: number) { if (session.state === "waiting") notify(session);

+ for (const tab of tabs) { fitting.push(tab); await git.commit({ message, files: staged }); comments.push({ line, body, author: "you" }); review.send(comments, { to: session.agent }); await lsp.start(language, { root });

const session = await agents.start(worktree); let selection = $state<Range | null>(null); const diff = await worktree.diff("main"); tree.open(path, { preview: true }); used += tab.width; return tabs.slice(visible.length);

+ await lsp.start(language, { root }); if (used > width) break; const session = await agents.start(worktree); let selection = $state<Range | null>(null); const diff = await worktree.diff("main"); tree.open(path, { preview: true });

return tabs.slice(visible.length); export function hiddenTabs(tabs: Tab[], width: number) { if (session.state === "waiting") notify(session); import { definePlugin } from "@grove/extension"; for (const tab of tabs) { fitting.push(tab);

− tree.open(path, { preview: true }); used += tab.width; return tabs.slice(visible.length); export function hiddenTabs(tabs: Tab[], width: number) { if (session.state === "waiting") notify(session); import { definePlugin } from "@grove/extension";

fitting.push(tab); await git.commit({ message, files: staged }); comments.push({ line, body, author: "you" }); review.send(comments, { to: session.agent }); await lsp.start(language, { root }); if (used > width) break;

+ let selection = $state<Range | null>(null); const diff = await worktree.diff("main"); tree.open(path, { preview: true }); used += tab.width; return tabs.slice(visible.length); export function hiddenTabs(tabs: Tab[], width: number) {

+ import { definePlugin } from "@grove/extension"; for (const tab of tabs) { fitting.push(tab); await git.commit({ message, files: staged }); comments.push({ line, body, author: "you" }); review.send(comments, { to: session.agent });

if (used > width) break; const session = await agents.start(worktree); let selection = $state<Range | null>(null); const diff = await worktree.diff("main"); tree.open(path, { preview: true }); used += tab.width;

+ review.send(comments, { to: session.agent }); await lsp.start(language, { root }); if (used > width) break; const session = await agents.start(worktree); let selection = $state<Range | null>(null); const diff = await worktree.diff("main");

used += tab.width; return tabs.slice(visible.length); export function hiddenTabs(tabs: Tab[], width: number) { if (session.state === "waiting") notify(session); import { definePlugin } from "@grove/extension"; for (const tab of tabs) {

− const diff = await worktree.diff("main"); tree.open(path, { preview: true }); used += tab.width; return tabs.slice(visible.length); export function hiddenTabs(tabs: Tab[], width: number) { if (session.state === "waiting") notify(session);

+ if (session.state === "waiting") notify(session); import { definePlugin } from "@grove/extension"; for (const tab of tabs) { fitting.push(tab); await git.commit({ message, files: staged }); comments.push({ line, body, author: "you" });

+ comments.push({ line, body, author: "you" }); review.send(comments, { to: session.agent }); await lsp.start(language, { root }); if (used > width) break; const session = await agents.start(worktree); let selection = $state<Range | null>(null);

tree.open(path, { preview: true }); used += tab.width; return tabs.slice(visible.length); export function hiddenTabs(tabs: Tab[], width: number) { if (session.state === "waiting") notify(session); import { definePlugin } from "@grove/extension";

− let selection = $state<Range | null>(null); const diff = await worktree.diff("main"); tree.open(path, { preview: true }); used += tab.width; return tabs.slice(visible.length); export function hiddenTabs(tabs: Tab[], width: number) {

+ export function hiddenTabs(tabs: Tab[], width: number) { if (session.state === "waiting") notify(session); import { definePlugin } from "@grove/extension"; for (const tab of tabs) { fitting.push(tab); await git.commit({ message, files: staged });

The most extensible code editor.

Built for working with agents, and every part of it is yours to change.

Build from source View on GitHub

Free and open source. Built on GPUI. For Linux today, with Windows and macOS on the way.

TabStrip.svelte overflow.ts

12function visibleTabs(tabs: Tab[], width: number) {

13const fitting = [];

14let used = 0;

−for (const tab of tabs) fitting.push(tab);

15for (const tab of tabs) {

16used += tab.width;

17if (used > width) break;

You, on line 17

Keep the active tab visible, even when it doesn’t fit.

18fitting.push(tab);

19}

20return fitting;

21}

23export function hiddenTabs(tabs: Tab[], width: number) {

24return tabs.slice(visibleTabs(tabs, width).length);

25}

12-tab-overflow · Claude Code

Tabs that don’t fit should move into a menu instead of getting squashed.

Read TabStrip.svelte
Created overflow.ts +24
Edited TabStrip.svelte +18 −4
Ran bun test tabs 9 pass

The strip keeps the tabs that fit and moves the rest into a menu. Ready for your review.

3 review comments · Send to Claude Code

Reply, or describe what to build

Claude Code

Extensions

Everything in Grove is an extension. Yours can be too.

Grove is built on the same extension system as the DeepSeek harness. There is nothing an extension can’t reach, and if you know Svelte, you already know how to write one.

Grove’s own editor, agents, Git view and GitHub pane use the same API your extension gets.
Grove’s interface is plain Svelte 5 components, drawn natively by GPUI, so an extension is too.
An extension is an ordinary npm package, with plugins, themes, settings, grammars and language servers.
Turn extensions on and off while Grove runs. Unloading one cleans up everything it added.

Greeting.svelte

import { Text } from "@neoworks/svelte-gpui/ui";

import { colors } from "@grove/extension";

let { text } = $props();

</script>

hello.ts

import { definePlugin } from "@grove/extension";

import Greeting from "./Greeting.svelte";

definePlugin({

inject: ["slots"],

apply(ctx) {

ctx.slots.register("statusbar", { component: Greeting, props: { text: "Hello from an extension" } });

});

main Hello from an extension Ln 6, Col 1

Features

Built for the way you work with agents now.

An agent in every worktree.

Start Claude Code, Codex or neo on its own branch, as many as you like. The Agents view shows what each one is doing and which ones are waiting for you.

Any agent

Bring the agents you already use.

Run Claude Code, Codex or neo side by side, one session per worktree, each with its own branch. The Agents view shows every session at a glance and which ones are waiting for you.

Meet neo

Screenshot: The Agents view with Claude Code, Codex and neo working in three worktrees

Screenshot: Three agents editing files at the same time while the editor scrolls smoothly

Native

Fast, because it’s native.

Grove is built on GPUI, the GPU-accelerated framework behind Zed. There is no browser and no webview inside.

Opens instantly

There is nothing to start up before your code is on screen.
Scrolls at your display’s refresh rate

Every pane, every diff and every line is drawn on the GPU.
Stays responsive

Even while several agents are rewriting your files at once.

The editor

A real editor at its core.

When you take over from the agent, everything you expect from an editor is there.

Screenshot: Which-key hints after pressing the leader key

Vim keybindings

With which-key hints, so the next keys are always on screen.
Screenshot: Added and changed lines marked in the gutter

Changes in the gutter

See what changed, line by line, as you scroll.
Screenshot: The command palette, filtered by a few letters

Command palette

Everything Grove can do, one shortcut away.

Tree-sitter highlighting

Colours that follow the structure of your code.
Language servers

They install themselves the first time you open a file.
File picker

Jump to any file in a few keystrokes.
Project-wide search

Find anything across the whole project.
Terminals

In a tab or in the bottom panel, right beside everything else.

Get Grove.

Free and open source. Build it from source today, with releases on the way.

Linux · available now
Windows · we’re working on it
macOS · we’re working on it

Build from source View on GitHub

Terminal

❯ git clone https://github.com/neoworks-dev/grove

❯ cd grove/native

❯ task install # JavaScript dependencies

❯ task run # build and start Grove

The most extensible code editor.

Everything in Grove is an extension. Yours can be too.

Built for the way you work with agents now.

An agent in every worktree.

Bring the agents you already use.

Fast, because it’s native.

Opens instantly

Scrolls at your display’s refresh rate

Stays responsive

A real editor at its core.

Vim keybindings

Changes in the gutter

Command palette

Tree-sitter highlighting

Language servers

File picker

Project-wide search

Terminals

Get Grove.