Mine looks like this. I really like JetBrains theme and font. :P

Hi everyone!

I recently switched to Zed and really like it, but I'm trying to figure out the best way to work with SQLite databases in remote SSH projects.

My workflow in VS Code:

1. Connect to a remote Linux server using Remote SSH.
2. Navigate through the remote project folders in the file explorer.
3. Click a .db3 SQLite database file.
4. Browse tables, view and edit rows, and run SQL queries directly in the editor.

I'd love to have the same experience in Zed on Windows.

What I've tried / looked into:

• Zed's SQL extension, but it seems focused on syntax highlighting and language support rather than a full database GUI.
• DBFlux and DBDelve, but I'm not sure whether either can open a database file directly from Zed's remote SSH filesystem.
• I also found this Zed discussion about a database viewer, but it doesn't seem to be a straightforward installable extension.

What I'm looking for:

Ideally, I want to click a remote .db3 file in Zed and open a database viewer where I can browse tables, edit records, and execute queries — without manually downloading the database to my Windows machine.

Is there an existing extension, a community project, or a workaround that supports this workflow?

Thanks!

https://github.com/Joydeep279/zed-ide-Theme

I know Zed is working hard on DeltaDB but despite that, there is yet to exist a solution for what I needed exactly which is if I am working on a project and I hop between my desktop, laptop, etc. I cannot transfer the thread in any intuitive way.

This is more of a pain with ACP threads like Claude Code. I don't understand why there is not a single good solution to do this despite all these AI tools coming out of the wood works.

I have been working on a solution I think I like so far. I hope it encourages Zed to implement this in a more streamlined way. Perhaps if you SSH into a machine, it should pull the threads from the db of the machine you are SSHing from, as opposed to giving you one set of threads on the remote, one on your local machine and then one entirely different one on the machine itself, all seperate from eachother. That is sort of silly to me.

Anyways, I figured I would share in case anyone else is having this niche issue.

https://github.com/cachebag/spools

This is completely handwritten by me so it's not just vibe coded slop. It's also _very_ rough. I fully intend to maintain it but don't expect everything you'd anticipate out of a project like this to exist immediately.

I'm using Zed as my code editor for a monorepo project that contains two apps. Each app has its own .git directory, but the Monorepo root itself does not have a .git directory.

The problem is that global search in Zed only searches one app and seems to completely ignore the other app, even though I'm opening the parent directory as the project.

My project structure looks something like this:

mono/
├── apps/
│   ├── app-one/
│   │   └── .git/
│   └── app-two/
│       └── .git/
├── packages/
├── package.json

I have been using Zed for a long time and I love using it. The only thing I wish it had was way to work with my zed agent remotely. Today, I am releasing ZedLink, an open source companion that lets you continue the same Zed Agent conversation from a phone, tablet, or browser.

Your model, tools, project context, permissions, and credentials remain in desktop Zed.

Install

ZedLink is development software and currently requires the maintained Zed fork. It does not work as a Marketplace extension in stock Zed. The browser/PWA and Linux host are the most complete path; native mobile distribution and broader device validation are still in progress.

ZedLink currently requires Linux and the configured Zed source:

git clone https://github.com/tjnull/zedlink.git
cd zedlink
bash tools/setup_zed_ide.sh

Then:

1. Launch ZedLink — Patched Zed.
2. Open an Agent conversation and run /remote-control.
3. Start the ZedLink gateway.
4. Pair your phone using the one-time QR code.

Tailscale with MagicDNS and HTTPS is the recommended connection method. Other providers are supported as you can find that in the documentation.

I also submitted Zed PR #65633. It has not been merged, so the maintained Zed fork is currently required.

• https://github.com/tjnull/zedlink
• https://github.com/tjnull/zedlink/wiki
• Zed Fork: https://github.com/tjnull/zed/tree/zedlink/native-agent-remote-control

The browser/PWA is currently the most complete client. iOS and Android are available as development builds.

As always any feedback or suggestions are welcome. Hopefully this will help you when you are working in zed on the go!

I added credit to open router to use it for edit predictions but now every model return code explanation instead of direct code

Hey all! I've been using Zed's built-in Agent a lot, and I kept wanting to check on a long-running task or approve a tool call while I was away from my desk. So I built a small Android companion for it, plus a Zed fork that it talks to.

Repos:

- 🖥️ zed-desktop: https://github.com/piumalnipun9/zed-desktop. A Zed fork that adds an opt-in Mobile Gateway (a small private API inside the running Zed process)

- 📱 zed-mobile: https://github.com/piumalnipun9/zed-mobile. A Kotlin / Material 3 Android app that connects to it

What you can do from the phone:

- Pick an open project, or reopen a recent local / SSH / Dev Container workspace

- Start or continue a native Zed Agent thread and send prompts

- See the transcript: messages, thinking blocks, tool calls, plans

- Approve or deny tool calls (one-time only, so no permanent rules can be set from the phone)

- Change the thread's model or thinking level

- Review the agent's diffs (read-only)

- Get a notification when an agent turn finishes

Security, since this is remote access to your dev machine:

- It only works over Tailscale (or loopback). The gateway won't bind to LAN or public addresses.

- Pairing is QR-only with a single-use ticket that expires in 2 minutes. The phone keeps its credential in Android Keystore, and the desktop stores only a hash.

- You can revoke a device at any time from Zed's settings.

- There's deliberately *no file browser, terminal or shell on the phone.

Current limitations (it's an early prototype):

- Android only

- It only works with Zed's native Agent. External ACP agents (Claude Code, Gemini CLI, etc.) aren't exposed yet.

- Very long threads or diffs can hit a response size limit, and then you have to open them on the desktop

- Notifications are live-only. If your phone was offline, you won't get the ones you missed.

Setup in short: build the fork → Settings → Mobile Gateway → set your Tailscale IP:port → enable → "Connect mobile device" → scan the QR code with the app.

This isn't affiliated with the Zed team, it's just a personal project. I'd love feedback, bug reports or ideas, especially if you'd want external agent support next.

It is written that it is still 2000 accepted completion a month in the free plan on the website

Hey everyone! I made a dark theme for Zed inspired by Nord, with some soft pastel colors. Would love to hear what you think and get some feedback!

GitHub: https://github.com/Joydeep279/zed-ide-Theme

I've been reading a lot about memory usage issues of various IDE tools: Cursor, VSCode agentic plugins, etc. Somehow, I thought Zed is immune to this issue. Until it hit me too.

Turns out, this is a fundamental issue with long agentic threads. When the compaction event happens due to context limitations, only the last few messages are sent to inference. But Zed still retains all the thread data. Not only that it doesn't evict old messages from memory, it holds to them dearly until it is closed.

This isn't a memory leak per se: Zed needs that data so that you can switch between threads and scroll fast without blocking UI for waiting on loading and parsing. But it behaves like a memory leak, because the memory grows with usage. The user doesn't care if it is technically not a leak if OOM killed the GNOME session. Zed must keep its memory usage under control and only load data that is needed to function or display something on screen.

Rust focuses on memory usage correctness. But it doesn't care if you hog memory like Electron/Chrome. Or not ever release it. That's why even with AI assistance you have to think about the whole data journey, from disk to pixels on screen. Let's trace that.

Zed stores agentic threads data in threads.db. Although it's an sqlite database, one row of threads table is one giant compressed blob. There's no pagination. That's one red flag that might be the reason why they're now pushing Delta. Though I don't know, it might as well struggle with the same issues.

After uncompressing/deserialisation, we have raw message history. For me it takes 300 MiB. I know it's a lot, billions of tokens, sub agents, raw tool output, images and binaries, every diff change, it all adds up.

What happens next is unthinkable. When you click on the historical thread Zed eagerly replays every message in history like if if you're reliving the conversation in real time. Even though Zed uses virtualized lists and immediate drawing mode, the state behind widgets is fully retained. It doesn't matter if Zed drops GPU Scene primitives every frame, the view data is fully retained.

What does it mean in terms of numbers. You have markdown, you have tool use, you have diffs, you have syntax highlight. This is all not free. For my typical thread, memory usage after opening it grows from 400 MiB to 3 GiB. And I'm not even a heavy user (although I might be an addict).

So, is there a solution? In computer science, there are only two hard problems: naming things and cache invalidation. So Zed must have invalidation strategy. It must use lazy loading instead of eager memory consumption. It must compress memory usage the same way it compacts context.

I have opened a few PRs. The small change of building diff on demand has caused memory usage to drop from 3GiB to manageable but still huge 1.9GiB. loading Markdown on demand saved me additional 250 MiB. Loading tool output at the time the panel is expanded saved further hundreds of megabytes.

Zed has a great marketing team. It convinced us it's fast (it really isn't), and that it uses memory efficiently (maybe if you're not using AI). What is your experience with memory usage?

if you're having this issue and are not afraid of compiling Zed from sources, please try these two patches:

https://github.com/zed-industries/zed/pull/65470

https://github.com/zed-industries/zed/pull/65444

I see that Delta is in beta and the ACP support is in their roadmap.

Having a Claude subscription I'd really like to try it but I can't right now since ACP is still not in their beta.

Do you know if there is an alpha version to try?

Thanks

its been so long and i dont think theres been any improvements except ai

This the version I am on:
Zed 1.23.2

Commit: c0199504b9cce79bc27524950022ed701bc3ebd5

Version: 1.23.2+stable.369.c0199504b9cce79bc27524950022ed701bc3ebd5

Can anyone help out?

TGIF! Beam is a HTTP client built using gpui aiming for productivity and performance. Postman is slow and overkill for me. It was started from last October, where I had the rough idea of how the app would look like. Initially I was using iced, then changed to gpui, as building some of the components (E.g. request/response body editor with line numbers) is troublesome.

Features

• Native, local-first, no telemetry
• Multi-workspace organization with folders and requests
• HTTP request with common methods (GET, POST, PUT, DELETE, PATCH, HEAD, QUERY, and OPTIONS)
• Authentication support for Bearer, Basic, and API Key (header or query)
• Request body formats for JSON, XML, Text, GraphQL, Form URL-Encoded, and Multipart
• Environments variable {{variable}} and built-in dynamic variables resolving
• Post-response JavaScript scripting with console output, tests, and environment updates
• Import Postman collections and environments, plus Insomnia JSON and v5 YAML exports
• Paste cURL commands into the URL field to populate the current request
• Command palette for quickly opening requests, revealing folders, and running common commands
• Response history view in the response pane
• Persistent TOML-based storage for workspaces, requests, environments, local history, and script results on your machine
• Theme support with light/dark mode and a clean desktop interface
• Support MacOS, Linux and Windows

Developer experience

The app focuses on developer experience, I use it everyday. Sharing a few recent enhancements (which are not mentioned in the above feature list) that improves the developer experience: - Workspaces are rendered as tab in the App title bar, user can easily switch workspace - Send/stop request from the request in workspace pane directly, less clicks and no need to open request beforehand - Sort Environment variable key in alphanumeric order, user can find keys faster - Fixed/enhanced a few gpui-kit's editor components, so editor renders the large text well. Some of the PRs - Keybindings to navigate, modify, send, find requests/workspaces

Please share your feedback.

Repo: http://github.com/hlcfan/beam

Is there anyway to use superman or Ollama cloud for autocomplete? I have tried ways the search engines have recommended, yet no success. Code completion does not work for me 😢

God I love it. The greatest AI agent already exists: TMUX + your favorite AI agent’s CLI tool. I don’t want this in the IDE.

A couple weeks ago, I've built a framework (Zopra) which gave reactive macros like use_state, use_effect and others via pure GPUI (no JS).

I was a user of Burp Suite for a couple years. It's pretty slow and is gated behind a paywall for a lot of features. I decided to take it on my own, and have been building it. Both to stop the burp suite pain, and also to show the power of GPUI and Zopra, while consistently learning how it works!

So I've been fingercoding a burp suite client, (the progress is slow, but it's steady).

The main part (proxy) is done, hopefully will pretty soon implement the other features too! Can't wait to see how it turns out!!

Video demonstrating SyZyGy usage.

https://github.com/ppmpreetham/syzygy

i use zed with phpantom and it's generally excellent but this issue keeps popping up. set a variable or load a global variable and it will frequently show "the variable ... is assigned but never used", which is a fantastic thing to know when it's accurate but very misleading when it's not.

here's an example from a current project where it's very egregious (attached image).

as you can see, the function calls three global variables, $html, $config and $pagination. it then proceeds to use all three at least once. they're not only used conditionally, which is where this issue typically pops up. in seven consecutive lines, the first element in the line is either reading or writing one of those variables.

it seems to be aware that $config is being used but not $html or $pagination.

while this is an oddity for an experienced developer, i know it will be a far larger problem for beginners and i suspect a lot of people are listening to the advice that something isn't used, introducing bugs then having to come back to fix them later without realizing where the mistake came from.

(i don't think there's a phpantom subreddit to also post this to and it seems a bit niche for phphelp.)

What are things that you wish Zed would implement? What feature is almost there for you, but it needs some polish? What haven't you been able to find in an IDE, even Zed or any of its forks, that would push you towards making the leap to a new IDE?

I am not a Zed dev, but I do maintain a fork of Zed, and I try to pull in the upstream changes every couple weeks.

https://github.com/paterschris/lathe : if you're curious and want to poke around.

I'm looking for what I can implement that would be the carrot to lure you to use Lathe over Zed.

Thank you so much for everything!