It's be kinda cool if Zed had a TUI mode (in that the rendering engine would generate VT escape sequences).
I've been editing directly in the terminal for many years and was looking forward to moving back to a real desktop IDE, but I bounced right off of this. Does it not happen for you or it's just not that bad? Does anyone know of a solution?
That's the one reason I actually did end up using vim, even if Gui editors are theoretically highly superior.
It's always there in the terminal with me. So you know how it goes, you set up $awesome_ide on a separate screen or what have you; start messing in the terminal, and then for quick edits you grab vim anyway. And once you have the whole edit/test/edit/test loop going, well, vim is still there. And hours later you find out the whole IDE has just been sitting there the whole time.
So yeah, I'm not married to vim I don't think. A nicer terminal editor would always be welcome? And if it has vi(m) bindings to ease me into it? Who knows.
It's a terminal editor with mouse support and sane key bindings.
Please update in 1 year
Generally I want things to "just work" and if there's extra fancy settings I'm happy to learn them later / slowly as a I go through it. Minor updates to plugins in Neovim would break things, a lot of the error output was next to useless, and I spent waaaaaay too much time debugging what was wrong.
I switched to Zed w/ Vim keybindings and it's a perfect balance.
And it never crashed on me, unlike VSCode which reminds me of Windows 3.1.
https://github.com/NvChad/NvChad
The author mentions switching from editor to terminal often - NvChad has built in terminal integration so you can toggle floating/vertical/horizontal terminals (whose contents persist when closed) with a simple keybind.
I too am growing tired of tinkering and want minimal configs. So much so that I had to force myself to stop using doom emacs in favor of neovim. Neovim setup is much simpler now that lua exists but i'd rather not tinker as much as I do.
Enabling/Disabling plugins is fun in a way when you wanna take the time to do that.
I might give zed a spin a few more times.
Can zed be run from a terminal over ssh or is it just GUI?
You can open as many terminal buffers in neovim as you'd like, AND at the same time you can open as many neovims in terminals as you'd like...
Why choosing GUI neovim client and switching back and forth? Truly don't understand it
- have a couple of windows open, each showing a different directory
- in one, open a file from it's directory, not by locating it in the file tree, but via the open dialog
- file opens in the other window
I get that my second step is 'wrong' but this behaviour is still annoying and feels buggy.
Also half my workspaces are on remote servers and Zed lets me switch between remote and local workspaces easy which I appreciate.
What drew you to Zed over VS Code?
Also I’m not immune to hype I suppose
I switched just to keep things interesting and didn't go back. That was last year maybe Sep/Oct.
I had to use VSCode to collaborate and like it in general.
I tried one of those AI IDEs for the first time today and I was pretty shocked how good it was even though I’ve used ChatGPT forever. They are going to be standard like git soon. Paid for by your companies
I'll give Zed's vim-mode a try, great post!
Yes, this is awful and something the default should've changed years ago instead of continuing this massive collective time waste. But presumably after 15 years you've configured almost everything you need? At least to the point of matching a static config file?
> Lua is great, but one JSON file is even better.
No way, it's a strict downgrade, you can have a simple lua table exactly matching json things, but then should you decide to do anything dynamic/complicated (which at one point even included formatting as Zed broke your config format on changes), you're stuck with json with no way out
> Installing plugins means updating them, which inevitably breaks things.
No it doesn't, just pin the version you the one that works for you and ignore the future? Or do you need that extra functionality from the updates? But then does Zed without a plugin even have this functionality?
But also Zed does plan to have plugins, so this won't be different?
> years ago instead of continuing this massive collective time waste.
This doesn't seem feasible, because that would go against the culture and long-term practice of doing things. That's why approach of "starting from scratch and doing it right without the baggage" like Helix's works so much better.
If Zed breaks things too much in the future (to the point that its JSON config doesn't let me do something I need to get my work done) I'll probably go back to using Neovim. We'll see how it plays out over time. For now I'm enjoying having less configuration knobs.
i'm used to a plugin- and config-light setup on my personal systems, with most of the customization being stuff like latex compilation and preview from a keybind rather than major changes to default behavior, but the whole "vim needs a bazillion lines of config!" thing isn't really true. some people like to spend a week bikeshedding it but it's by no means necessary. i've had the same vimrc for years and years and basically never need to change it.
But I agree with you and the OP that the defaults with zero configuration do matter and that I wish we had that in every editor.
Yeah that single line makes me doubt the whole post, how can a format without comments be an upgrade to any configuration file is beyond me. My customized configs were full of ‘this was broken on this day by something else, link to obscure thread’ before I accepted the way of default.
Same! I run neovim in tmux together with stuff I hack on. I switch beteen tmux windows with shift-arrows and it works so well. I run this full screen in Ghostty. No distractions.
I try Zed and VSCode and I always come back to this setup. It works so well for me personally.
The lack of debugger support will put some off, but I bet they'll get to it someday. It's already progressed so much in the four or five months I've used it (esp. Vim Mode).
Edit - also, as far as config goes, "distros" solve this. LazyVim is everything I want in an editor and more, with zero config. Installing LSPs and plugins is super easy, arguably even easier than with editors like VSCode or Zed.
Golly I hope they succeed.
Compare that to vim where it's truly an open source product.
People being able to adapt their software to their own needs by making changes to the code is exactly what open source is about. This is good.
What is a problem though, is to have the code merged in the main repository requires you to gift them the rights to your code (not just license it). They are also not very clear about this in the summary of their CLA: “You're giving Zed permission to use and share your contributions (like original works or modifications).” which could be misunderstood to just be a usual open source licensing agreement, but seems to be complete handover of copyright: https://zed.dev/cla
This is not good, and something people should be more aware of when contributing.
The alternative would be to presume that I have some kind of ownership over it by having contributed to it--and I'm a bit allergic to the idea that code can be owned.
Where there wouldn't be any money in the first place? I don't see popular vim plugin authors getting paid.
Maybe I'm not understanding your point.
I will never understand how you go back from a very customized editor setup to the one with "reasonable defaults with little to no things to configure".
Great talk on this topic by TJ: Personal Development Environment: https://youtu.be/QMVIJhC9Veg
Switching is not feasible for me until they get mini.surround[0] and Flash.nvim[1], particularly Flash's treesitter mode (see screenshot of [1] to get an idea).
They work particularly well together to select semantically meaningful chunks of code and add/remove/change surrounding parens/braces/curlies/etc.
What I don’t understand is the development workflow that includes so much text manipulation. If you’re writing new code, there’s nothing to manipulate. If you’re refactoring existing code, wouldn’t you want the support typical AST-based refactoring tools provide? Where’s the sweet spot where shuffling strings around makes sense?
That’s not sarcasm. I’m genuinely asking.
https://github.com/baketnk/l.nvim (self-shill, docs overhaul needed)
which was inspired by the original:
https://github.com/yacineMTB/dingllm.nvim
Also brand new from ggerganov: https://github.com/ggml-org/llama.vim
dingllm is very straightforward, you submit your entire selection/buffer and it streams out to the current position. mine is a bit more complex with configurations, context management and so on.
The thing I always tell people is just roll your own. The docs are there, the LLM is there, use them. At the end of the day it's just an http call against text from your buffer to put text in a buffer.
I think the only thing that is really outstanding for Windows is SSH support.
Everything largely "just works" and my experience getting a plugin with syntax highlighting working and merged for a DSL I maintain was very smooth.
Adding individual files in Zed feels so cluncky by comparison.
Zed felt very nice, definitely reminded me of the good old days of Sublime. With literally the two features mentioned above, I think I would switch… but it’s easy to say until it happens for sure.
I really liked everything about it including the much better LSP support and the base key map for Sublime Text was very close so I felt at home quickly.
Then I tried actually writing code in my usual workflow and this is where things started to fall apart. I’ve been writing in Ruby for almost 10 years now and when I type things like `def<tab>` I’m used to Sublime filling in the snippet and allowing me to quickly enter and tab through the components. Same for a bunch of really common Ruby concepts like blocks. I found this to be very limited and even though I created custom snippets they never would render with the correct indentation. I think the Ruby language extension just needs some additional work and probably doesn’t get much attention. For me I didn’t have time to figure it out and contribute so I went back to Sublime Text.
I will definitely continue to play with Zed and see if it gets better because of the native AI integration. I’m not an AI fanboi and I usually avoid it, but being able to supply the open and existing files as context when asking the assistant to generate things like tests performed much better with context than without and were much closer to how we write and format tests.
this resonates with me. i've spent so much time configuring neovim in the terminal (kitty) and i've never had everything work 100% of the time. simple things just like seeing an entire typescript error are challenging to get working. those errors just continue on one line outside of the screen.
with LLM's the tradeoff tipped in the favor of cursor with the neovim extension.
> 2. It just works
so i switched to cursor last week from neovim in the terminal and this is how i feel. but, i'm not going to invest more time to check out Zed now that i just got cursor set up the way i like it.
but it's great to see all the progress in IDE's lately.
But man. File trees and tabs are the worst DX I can possibly imagine. Try as I might, I just could not get used to the tab and tree workflow. Creating new files killed me. Hiding the tab didn’t really help because the editor assumes you’re using tabs and at that point it doesn’t feel like buffers, it feels like tabs with the tab bar hidden (go figure).
I’m not even a buffer power users, but I think the default assumption of buffers over tabs, and explore over a file tree, led to 1000 other great decisions that make vim vim.
I think unless the zed core team really tried to move away from tabs and trees (and I don’t think they would nor should) they’ll fail to capture a meaningful share of vim users
- none or very minimal config
- install lazyvim or other tool
Then you're done! The option is still there if you really like tweaking things, but I really enjoy the out of the box experience with lazyvim.
Probably JetBrains is best in class. How much config you need in Zed to get productive with e.g. PHP dev vs install PhpStorm?
I think there is a spectrum of tools where Neovim requires more customization and JetBrains is the most Just-Works. Everything else in between doesn't just work and requires customization in their opinionated way.
> Why Zed?
> 1. Vim mode
Out of all non-vim editors with Vim mode JetBrains is again has the best integration via IdeaVim.
> 2. It just works
Do I need to install extension and configure them?
> 3. JSON Configuration
Comparing JSON vs Lua Table I can't see any benefits. Most configs in Neovim I just copy pasted from the GitHub repo and changed couple things.
> 4. Configuration autocomplete If you need a good autocomplete for a config file you probably spending too much time on your config.
> 5. Native LLM integration
Nice
> 6. Fast!
Nice
I have been using Zed for a few months now and I think it's better than anything else, but not good (yet). I feel like it's still young enough that the number of problems is not just decreasing, but there seem to be new problems regularly.
Having a config file and trying to keep it healthy over the years requires such mindset. It might eventually break because you got sick of it, but there are thousands of parameters to that problem. Are you a plugin freak, are you trying to change every single default keybinding, do you try new things, which terminal emulator you like, what about FOMO…
I had an on and off relationship with Zed, because in the beginning there were some bugs and many things were missing, but they are adding and fixing a lot of things and at the current state I use it more than Neovim although I have a relatively maintenance-free config. I always liked Vim/Neovim because I had shitty computers throughout my life and using a snappy terminal interface to write was always easier than using a chunky editor. But nowadays things have changed and Zed is extremely fast too, so this advantage of snappiness is unrelated now. Plus the design is minimal and well-thought, which I always appreciate. Next to VSCode Bloat, I find it extremely easy to look at.
My dream was to have Vim motions by default in every single piece of software like editors, browsers, PDF readers and even Finder. What Vim changed is the motions and the way you interact with the computer and this does not need to be exclusive to terminal interpreters anymore, so I appreciate the effort of editor developers to shift the paradigm to using what Vim invented. Zed does it good and I hope they eventually reach to a state, where I can completely switch.
It makes me wonder if highly configurable software plus AI can be combined for an outcome that "just works" while also being highly personalized. One thing that kind of surprised me about Zed is that the AI assistant isn't very good, in my experience, at answering questions about how to configure Zed. Models have their cutoff date, of course, but this seems like low hanging fruit for some context injection based on keywords. An editor feature that can help me quickly implement my preference choice and get back to work without a visit to the docs would be truly adding value.
The /workflow command which was there earlier is also removed now, so you have to copy paste code which sucks.
I have Ctrl+` set to switch focus between the editor and the terminal panes in VSCode, so I can toggle between them pretty easily as this is also my workflow
If anyone's wondering, here's what I have in my keybindings.json
{
"key": "ctrl+`",
"command": "workbench.action.terminal.focus"
},
{
"key": "ctrl+`",
"command": "workbench.action.focusActiveEditorGroup",
"when": "terminalFocus"
},It’s a nice short cut if you have a keyboard with backtick to the left of 1 in the numeral row. If you’re from a country where keyboards have a different key there, I would recommend setting up a short cut manually.
I know people who use ^Z to suspend vim and then foreground it again.
You don't mind losing all your editor state? If you don't like working with multiple terminal windows, why not open a term within vim with `:term`?
As the author describes though, I found myself copy-pasting a lot between LLM chat and editing buffers. In tmux, I have a really simple function that copies select panes (using tmux capture-pane) into my prompt, or I can give it full files for context. Most of the time though, I can do something like `llm -t 0 -t 1 'what is this libSSL error indicating? here's my code', where -t 0 gives it my vim pane and -t 1 gives it the terminal I'm running things in. I've been surprised that this somewhat rudimentary approach has felt far more effective than the more sophisticated editors I've been trying.
Is this just me? Does it seem to others that the LLM-enabled editors coming out these days still require a lot of copy-pasting of context that can be easily provided with just a dump of tmux output?
Everything-is-just-text might be crude but dang does it make quick and dirty LLM integrations a snap!
because when the very customized setup inevitably breaks the amount of headache you have is roughly proportionate to the amount of customization, whereas software with strong defaults tends to deal with that for you.
This is particularly the case with neovim which, in almost deliberate defiance of any systems thinking, just tends to consist of a few dozen moving parts loosely tied together and you have to sort of pray that updating some doesn't just break things. Paraphrasing Russ Ackhoff, if you take the best part of every car and put it together you don't get the best car, you get something that doesn't even drive, this is how I've felt more than once with very bespoke editor setups
Just hope that nothing breaks in an OS upgrade.
Or, to put it another way: every step you take away from the mainstream has a cost, so you had better know how much you are willing to pay and budget your quirks accordingly.
> every step you take away from the mainstream has a cost
Customizing neovim is mainstream
That's one of the reasons why I chose Vim over Emacs after switching back and forth for a while.
I do prefer the design of Emacs because I prefer having full control over my environment - I even coded more than a couple of tiny, application-specific editors - but sometimes I have better things to do than e.g. reading docs or searching for a plugin/extension mod that does what I need, or do it myself; sometimes I am a mere luser who want things to "just work" out-of-the-box.
Sublime has great language support out of the box but poor LSP support (basically outsourcing it to a user plugin instead of having a native integration).
Zed has great LSP support but ”poor” language integration (also outsourcing the language plugins to the community, which makes the vary in quality and feature set).
But Zed has great AI integration which Sublime completely lacks, if you’re into that.
I don't know if I'm an AI fanboi or not, but for generating things like factorygirl definitions and simple rspec unit tests, GPT is seriously good (in the sense that it saves me tedious work, not that it is particularly fantastic).
The legally binding section only talks about giving them an infinite free license to it. It does not say you hand over your copyright, so the summary seems correct.
I still don't think you should sign it. The editor code seems to be variously under GPL, AGPL and Apache 2.0, all of which would be fine without one.
There is something strange where you are sort of making your product better through open source contributions and yet all of the capital gains from your company's eventual sale will only go to you.
There is something really weird and nasty about that.
So it's fine for X11 terminals, but not for /dev/tty2
Don't forget you can just :!some-shell-command though - not just in vim but in lots of programs even.
I understand "just make it work" mentality, but it might be useful to have deeper understanding of a tool you use several hours everyday.
1. LSPs differ per-language, and so I'm never sure whether I'll get lucky today or not. It's more reliable for small changes to talk about them in terms of the text.
2. LSPs are also quite slow. For example in Zed I can do a quick local rename with `ga` to multi-cursor onto matching words and then `s new_name` to change it. (For larger or cross-file renames I still use the LSP).
3. I err as a human continually, for example in Rust a string is `"a"` and a char is `'a'`. It's easy for my javascript addled brain to use the wrong quotes. I don't know of any LSP operation that does "convert string literal into char literal" (or vice versa), but in vim, it's easy.
We are slowly pulling in support for various vim plugins; but the tail is long and I am not likely to build a vim-compatible Lua (or VimScript :D) API any time soon.
For example, most of vim-surround already works so you could get the most used parts of mini.surround to work with just a few keybindings `"s a":["vim::PushOperator", { "AddSurrounds": {} }]`, but rebuilding every plugin is a labor of love :D.
At mega-scale, even IDE based tools are skipped in favor of automated tools such as Refaster/OpenRewrite that can refactor 10s of millions of lines of code at once.
I do find myself occasionally using, say, a regex find/replace to change something project wide. But most of the time (95% to put some arbitrary number on it), once I’m beyond the scope of single function, I use AST-based tools to ensure changes are correctly reflected in other files or parts of the project.
So, I’m trying understand to who lives in my 5% long enough that they the need what is essentially a highly specialized regex. Are they doing cross-project changes based on text? Do they have giant functions where that’s not a concern? Are their projects just smaller and they have many of them?
I definitely see the allure of having a smaller, faster editor. How far are people actually able to push that paradigm?
In my configuration vim will save (among other things):
- Cursor position
- Undo history
- Register state
:term is clunky for me, mainly because my muscle memory is to just :wq
I got it working as seamlessly as I could once just in an attempt to use it but I stopped pretty quickly.
I run a pretty light vanilla vimrc (60 lines maybe) and with two lines you can enable vim undofiles and returning the cursor to the last location upom reopening a file. For me, quitting vim is functionally equivalent to ^Z?
Retaining positions, buffers, and edit history between sessions is all straightforward in vanilla vim though. Unless you run an autolinter or formatter that edits your target file and wipes the history.
I don't use any other LSPs which have a long warmup time, but if I did then they can also be used behind ra-multiplex.