I'd imagine Jetbrains users are much more willing to pay, and the non-AI intelligence Webstorm has baked in save me almost as much cognitive load as Cursor does if not more compared to base vscode.

I tried Continue but it wasn't very smooth at all.

[1] https://supermaven.com/

I prefer to stay with addon

Edit: I see it, this is in their newest blog post

https://x.com/SupermavenAI/status/1835743882971426837

I hope they use Jetbrains as a base instead of VS Code (or roll their own). I strongly prefer IdeaVim or over the one in VS Code. It's the main reason why I don't use Cursor.

Happy user for a few months now :)

Edit : This is only my guess, I have no internal knowledge of Cursor.

I love their products, and I would be sad if they can't stay competitive, but it looks like they are taking all the wrong turns.

Honestly speaking I'm not a big fan of chat based assistants, which was one of my complaints about IntelliJ's own assistant. Auto-complete feels more natural, although I can see that the suggestions might be more accurate and to the point with the chat based ones.

I would know, I made the mistake of paying yearly.

The thing that's really keeping me in Cursor (vs decamping for Zed) is NOT the Cmd K or the sidebar chat. It's actual Cursor's Tab autocomplete model. I've tried many other tab completion models and Cursor Tab blows them out of the water. Supermaven's new release is promising, however.

For the use-case you're solving for (issues with code-privacy), I think something like https://codeium.com/ does already allow for on-prem deployments with enterprise support. I'm trying to think of who would be served well by a fork of VSCode vs Continue.dev or something like a codeium VPS deployment.

It's definitely not boilerplate level code - but it also also stops well short of architecture level work. Here's a recent prompt of me trying to implement line-by-line diff generation: https://pastebin.com/WRJpNwqc

When I need to do architectural/design work, I do it in multiple passes, not generating any code, just lots detailed text with tons of feedback/back-and-forth with the model.

I'm on the pro plan but it's not enough for my needs - I run through the quota in 10-15 days. Then, I revert to using Sonnet 3.5 via API key.

There are quite a few extensions and AI editors offering the snippet-like 'tab autocomplete', but Cursor are the only ones afaik who have nailed the full file no-look 'tab-tab-tab-tab autofix' workflow, with what I assume must be a combination of monaco/vscode hackery similar to what you're doing, and their own tuned model (i.e. not an off-the-shelf llm). Is this the piece you're going after when you say 'all of Cursor's core features', or are you primarily focused on something else?

On the topic of extensions, as an occasional user of Cursor I noticed that they've always been able to quite happily 'import' extensions you've already downloaded to a local VSCode profile, which makes sense, but they've occasionally struggled to use the same marketplace APIs for searching for extensions. I'm not sure what you're hoping for here, but I'd suggest you settle for that approach as a starting point. Also be conscious that you're dealing with Microsoft, so be mindful of things like their brand guidelines[0], and avoid telling the world that you're 'hacking away' at their APIs. These things may seem insignificant and it's true that they probably won't cause you a problem unless you're successful.

Lastly, assuming that you're hoping to recruit contributors (which I assume is some of the motivation behind this post): you really need to sanitise your Github workflow and your repo CI. Your commit history[1] currently seems to mostly consist of you updating your docs and committing straight to your main branch with no review process or checks, and the only commit I can see that does have any kind of check in place, your initial commit, has a failed monaco check that you seem to have subsequently just disabled. You'll need to tidy this up a _lot_ and establish a testing baseline if you want to successfully scale the project or attract the calibre of contributor you'll need to be successful.

Hope that helps, best of luck with the project!

[0]: https://code.visualstudio.com/brand [1]: https://github.com/voideditor/void/commits/main/

I'd like to continue using Cursor but I'm don't want to have to buy Claude subscription twice (Cursor uses claude under the hood), and I prefer claude sonnet over chat-gpt.

This seems to work pretty well for Codeium, which offers its product free to consumers (at a loss), and is still able to make net profit from enterprise companies. At least that's the plan for now!

Is there anything more than this?

Storia-AI/sage: Chat with any codebase with 2 commands

I haven't tried this myself so I apologize if it ends up being bad, but I've seen Aider [0] get linked a few times from people who wanted a CLI solution for AI code completion.

[0]: https://aider.chat/

In use, treesitter-derived approach seems far effective than rag.

Aider lets you pair program with LLMs, to edit code in your local git repository. Start a new project or work with an existing git repo. Aider works best with GPT-4o & Claude 3.5 Sonnet and can connect to almost any LLM.

https://aider.chat/

See LLM Leaderboards as well: https://aider.chat/docs/leaderboards/

- https://github.com/yetone/avante.nvim

Did not have the time to test them yet and there are probably more.

However, I found Theia (https://theia-ide.org) on HN (like a bunch of other cool things; this is one way I justify the time I spend/sink on this site) and find it a much better fit for our OSS goals (foundation owned, open-source marketplace) with full mod-ability while being compatible to VSCode extensions API (in theory). I recommend you look into it for your app.

>Microsoft also made its extension marketplace closed-source

Ehm, Open VSX Registry exists.

> allowing AI to edit multiple files at once

Cursor already modifies multiple files at the same time. I typically do this by pressing cmd+shift+I and in the left side of the window the required files will be shown as they're being modified.

One critical question to the users:

Is Void able to understand the source code files from the project as a whole?

What I mean is being able to read the project, and then make suggestions based on the code that was written and propose new functions? For example, I would see it as fantastic to write unit tests where I'd say: "Please write a unit test that is verifying the functions on ABC.class" or "update the unit tests for ABC.class".

I know it is difficult for an LLM to create a valid result on the first try, but at least it does same me a lot of time creating a skeleton with most of the functions and samples already there. Most times just have to fine tune or fix a few parts but can say it amplifies my output speed by at least 10x to have that kind of functionality.

What is your impression? Can it read all source code files on the project?

Hard sell to choose you especially as a full on editor replacement (as well as a copilot replacement) without a demo or even gifs.

Can't you just do your own "Copilot" extension and plumb in an instance to ollama? Isn't that what Continue does? https://marketplace.visualstudio.com/items?itemName=Continue...

They're simply throwing money at similar projects in the same space, hoping one will stick, without any special insight or reason why one should be more successful over another.

I guess similar theme can be seen in LLM/AI space in general, or previously in the streaming services, just throw as much money at the problem in the hope that your solution will stick, without any significant and clear differentiation.

Oh there's a lot more than that.

Heck, even centuries ago, they'd fund multiple ship crews to navigate the Earth, hoping one would find smth interesting.

It's the model that works in high-risk, high-reward endeavors.

Are there limitations in the extension APIs that make it hard to implement?

Cursor has a pretty polished experience, but I keep coming back to VS Code and using continue.dev, which is a lot rougher around the edges, because the UI works well enough.

(Void is HN backed)

https://zed.dev/

ssh server is still in early stages, not even p2p yet.

The requirement for extensions to be built in rust only makes it harder to adopt.

When they these 2 things get solved and the editor remains fast, it might actually be very tempting to replace vscode with zed.

Vscode is fantastic but tends to become bloated quickly....

Extensions like Codeium do the most naive thing possible by writing something like <<<<<<< DIFF >>>>>>>> in your file, literally breaking syntax highlighting. Others like Copilot are super buggy.

Right now Void is built on top of an extension, but we're also modifying and hooking into parts of the IDE to make a more native UX.

> Host your own models locally, or communicate directly with your favorites.

Looks fantastic, will happily try this!

This is not what open source means.

I don't think so.. Utilizing another data source, does not mean they're required, or even permitted in a lot of cases, to distribute that with their software/service.

That's open source, just because you need an internet connection doesn't preclude the 'open-source'-ness right.

I think there is a good discussion to be had over the licensing of LLM's and the fruits of training data, as well as that of the training data itself, but when it comes to the software itself, it's hard to argue what is and isn't open source.

What is the plan when VS Code introduces all your features?

So I went a’hunting, and settled on the Codeium vscode plug-in free plan which while not as good as cursor/sonnet combination but is quite capable and their “free” models are capable enough for what I am working on (believe they even use a llama 3.1 model— I think they have various models, but left it on the “base model” and it’s been pretty good)

Is there a technical limitation of the extension APIs or is it easier to “market” a new editor than an editor extension?

While adoption for individuals and small companies might be easy, a lot of bigger places already have other integrations with existing IDEs and displacing those for yet another IDE will be a hard ask

Someone else mentioned monetization, which may be the real reason.

> VSCode extensions have very limited control over the UI of the editor. Our Command-K and Copilot++ features aren’t possible as extensions. Same for much of what we want to build in the future!

[1] https://forum.cursor.com/t/why-not-a-plugin/2448/2

I wonder if they could have created a "Super Plugin" interface instead of a Cursor specific fork and try to get it merged to VSCode or VSCodium or at least keep as a new shared platform for deep customisation instead of balkanisation by everyone interested in doing something similar.

VSCodium does not do any development but only build VSCode codebase to be without all Microsoft telemetry and proprietary stuff and use open-vsx marketplace.

> VSCode

I will leave it as an exercise to the reader to think of some reasons why would VSCode team refuse to accept such change.

This is a great question. We think extensions are often buggy (e.g. Copilot, where the selection jumps), or unable to integrate very naturally (e.g. Codeium, other open source extensions). For example, a lot of extensions use the quick pick dropdown for the user to enter a prompt, which feels unnatural. Owning the IDE like Cursor is important to get around these issues, and we think this is why Cursor is so popular.

> While adoption for individuals and small companies might be easy, a lot of bigger places already have other integrations with existing IDEs and displacing those for yet another IDE will be a hard ask

You're right about IDE adoption. We want to build on top of an already-popular to help us reach smaller players, and hopefully we can win over larger companies in the long run with privacy and by centralizing nice AI features.

I don't know about VS Code, but I remember Atom was refactored to use manual DOM updates because the performance penalty of using React wasn't worth it.[1] By the way, isn't OOP by far the most popular paradigm for building desktop UIs? I imagine VS Code is a difficult codebase to work with that has a lot of intricate code (as is usually the case with large software projects), but that's a strange piece of criticism :-)

1. https://github.com/atom/atom/pull/5624

> By the way, isn't OOP by far the most popular paradigm for building desktop UIs?

Yes, but I wish it wasn't. My day job is desktop development (with Electron), and I avoid OOP as much as I can and try to use a functional approach. After jumping all over the VS Code codebase to try to understand how some of this stuff works, and seeing how hard it is to navigate, I think heavy OOP is a bad idea.

I think a lot of people don't consider how complex text editors are and then there are the complexities of an IDE, or extensions, to be able to interact with it.

ropes? gap buffers? https://code.visualstudio.com/blogs/2018/03/23/text-buffer-r...

how vscode does it,

- https://code.visualstudio.com/blogs/2018/03/23/text-buffer-r...

- https://en.wikipedia.org/wiki/Piece_table

I'm just saying, that general graphics editors is above that and do just fine with React.

For the marketplace, can you not use Open VSX [1]?

[1] https://github.com/eclipse/openvsx

Hard pass.

Sorry but you can pry IDEA from my cold dead hands or at least VSCode doesn't hold a candle to it IMHO. And no, I'm not looking for a discussion on VSCode vs IDEA.

Building a new code editor for a single feature is a dead end in my opinion.

[0] - https://github.com/trypear/pearai-app

I would recommend update double.bot landing page to have all features shown in few gifs on the same page and 'show in action' short video' - continue.dev had actually pretty good landing page. CodeSnap is probably something similar like cursors' 'apply' but double.bot landing page feels more like documentation. Also at this stage probably worth to add additional comparison to cursor same like you have for copilot

Anything else we could do to make double.bot a more compelling option for you?

I'm sick of dev tools being built around web browsers. We used to have fully native apps in the 90s and 00s that didn't require so much complexity compared to today.

Edit:

Forgot to mention that it also is powered by vim under the hood, but that's a strength in my eyes.

https://github.com/onivim/oni2

The success of Void is tied to how well you implement the part in which AI reasons about multiple files. This is where all the sauce is in Cursor at the moment imo.

And well, complain about it on hn obviously.