hckrnws

Hi, I tried the model and I am super impressed by the performance/quality. Thanks for making this open source!

I am the author of this Neovim plugin for edit completions. I was able to integrate it with the Sweep Edit model.

For anyone who is interested: https://github.com/leonardcser/cursortab.nvim

I remember using Qwen 2.5 Coder for autocomplete with Continue.dev, that experience was a mess both in JetBrains IDEs, as well as Visual Studio Code.

People posting stuff like this is really cool because otherwise it kinda feels like nobody gives a crap, for example even with Cline/RooCode/KiloCode there’s no good way for me to hook up an autocomplete model that either runs in Ollama or maybe a remote Cerebras Code model, like KiloCode doesn’t have a proper model configuration option even if it has it for the chat or regular agentic stuff - I don’t get why autocomplete is such a special case.

I guess what I’m saying is that I’m glad someone’s at least trying so I don’t have to keep a Copilot subscription just because I genuinely like their autocomplete and the rest of it is basically wasted: Claude Code and Codex and others are better for the actual chat/agentic stuff, KiloCode and others are really nice IDE plugins.

llama.cpp has an extension for VS Code, but configuration UX is utter crap

Sometimes when I use a plugin like this I get reminded just how much of a productivity nerf it is to code without an autocomplete AI. Honestly in my opinion if you write a lot of boilerplate code this is almost more useful than something like Claude Code, because it turbocharges your own train of thought rather than making you review someone else's, which may not align with your vision.

This is a really good plugin. I'm a diehard JetBrains user, I tried switching to VSCode and its various forks many times because of AI but muscle memory from years of use is hard to override. And for a lot of languages JetBrains is just much better, especially out of the box. But they dropped the ball so hard on AI it's unbelievable. Claude Code pulled it back a bit because at least now the cutting edge tools aren't just VSCode plugins, but I was still missing a solid autocomplete tool. Glad this is here to fill that niche. Very likely will be switching my GitHub copilot subscription to this.

I also really appreciate publishing open weights and allowing a privacy mode for anonymous trial users, even if it's opt-in. Usually these things seem to be reserved for paying tiers these days...

I have always said this and had people on HN reply that they don't get much use out of autocomplete, which puzzled me.

I'm starting to understand that there are two cultures.

Developers who are mostly writing new code get the most benefit from autocomplete and comparatively less from Claude Code. CC is neat but when it attempts to create something from nothing the code is often low quality and needs substantial work. It's kind of like playing a slot machine. Autocomplete, on the other hand, allows a developer to write the code they were going to write, but faster. It's always a productivity improvement.

Developers who are mostly doing maintenance experience the opposite. If your workflow is mostly based around an issue tracker rather than figma, CC is incredible, autocomplete less so.

I’m in the “write new stuff with cc and get great code.” Of course I’ll be told I don’t really know what I’m doing. That I just don’t know the difference between good and bad quality code. Sigh.

Hopefully not too offtopic: why so much boilerplate?

I see most would-be-boilerplate code refactored so the redundant bit becomes a small utility or library. But most of what I write is for research/analysis pipelines, so I'm likely missing an important insight. Like more verbose configuration over terse convention?

For code structure, snippets tempting[1] ("iff[tab]" => "if(...){...}") handles the bare conditional/loop completes in a more predictable way and offline/without a LLM eating into RAM.

[1] https://github.com/joaotavora/yasnippet; https://github.com/SirVer/ultisnips; https://code.visualstudio.com/docs/editing/userdefinedsnippe...

I agree with you. I do have some local model LLM support configured in Emacs, as well as integration with gemini 3 flash. However, all LLM support is turned off in my setup unless I specifically enable it for a few minutes.

I will definitely try the 1.5B model but I usually use LLMs by taking the time to edit a large one-shot prompt and feed it to either one of the new 8B or 30B local models or to gemini 3 flash via the app, web interface, or API.

Small purpose-built models are largely under-appreciated. I believe that it is too easy to fall into the trap of defaulting to the strongest models and to over rely on them. Shameless plug: it is still incomplete, but I have released an early version on my book ‘Winning Big With Small AI’ - so, I admit my opinions are a little biased!

do you know a good way to give context files in emacs? currently i have to either do ctrl-x+h to select file content of individual files to give to ai or copy files themselves from ai's chat interface. I would much prefer selecting all files at once and get their content copied to clipboard.

Yep. I'm coming to resent Claude Code and tools like it for taking me out of direct contact with the code.

I think we're still in the early days of these systems. The models could be capable of a lot more than this "chat log" methodology.

Agree about JetBrains dropping the ball. Saddens me because I've also been a diehard user of their products since 2004.

Glad to hear I'm not alone, the latest releases of JetBrains have been so bad I finally cancelled my subscription. VSCode has been a nice surprise, "its giving old emacs" as the kids would say.

I am curious about how both of you think Jetbrains is dropping the ball so much that you are no longer buying the tool.

You are still using it but no longer getting updates?

I use free RustRover for my open source work. I have not purchased a (new) license for my commercial work, because I haven't been getting as much value as it since my flow has switched to primarily agentic.

Mainly, they're pushing Junie and it just isn't that good or compelling, when faced off against the competition.

The key thing for me is that I think they had an opportunity here to really rethink how LLMs could interact with an editor since they potentially controlled both the editor and the LLM interaction. But they just implemented another chat-based interaction model with some bells and whistles, and also were late getting it out really, and what they delivered seemed a bit meh.

I was hoping for something that worked more closely inside the editing process, inline in the code, not just completions and then an agentic log alongside.

I also don't like that I can't seem to get it to work with 3rd party LLM providers, really. It seems to allow specifying an OpenAI API compatible endpoint, but it's janky and doesn't seem to allow me to refresh and manage the list of models properly?

It just still seems half-baked.

I love Opus and I am a heavy CC user now, but I don't like that Claude Code is taking me out of my IDE, away from hands on with the code, and out of my editing process.And I don't like how it tries to take over and how weak its review flow is. I end up almost always with surprises during my review process, despite my finding the quality of its code and analysis quite good. To me there was a real chance here for a company like JetBrains to show its worth in applying AI in a more sensible way than Anthropic has.

VSCode and Zed have no appeal to me though. I've mostly gone back to emacs.

In the meantime, their IDEs themselves feel a bit stalled in terms of advancement. And they've always suffered from performance problems since I started using them over 20 ago.

I dont want to hand edit i want the output of better ai model with edit instructions like //update here <code> // new code <code> insert here etc. and local model read the files and apply the updates. I tried generating patch format but both bigger models fail to generate it accurately and smaller models have hard time in using them. Is there some way to do this with this kind of model? or its for completions while editing only?

I've been waiting for something like this for ages. Cursor making me pay $20/month when all I use from it is autocomplete was always a little annoying, especially as they changed the UI to push agents more and it got in the way. I was even considering doing it myself but wasn't sure about gambling on models small enough to run locally being smart enough to do anything useful.

I threw together a vscode extension to run it and while the extension is rough, the model seems decent. I'm trying to keep my expectations contained, in the past local models have been absolutely terrible for inline completion, this seems much better already. I hope this kicks off more competition.

Very cool!

I understand that the 1.5B is small enough to run locally... but does it actually in the Sweep AI Jetbrains plugin? That is, if I install the plugin, will I download the model automatically and the plugin doesn't phone home?

no, as far as I can see there is no way to configure the Jetbrains plugin to use a local endpoint.

Why not?

Can someone make a better plugin?

Yes, I get the same vibe, as one has to sign in to their site to use the plugin. Kind of grimy for them to seemingly imply that it is locally run when it isn't.

Can this be used offline in Jetbrain IntelliJ? Looking at the plugin, it looks like it requires sign in and then it uses the cloud based model instead of the local one. Can't tell.

This is really awesome detail. I’m very impressed by the amount of care taken to identify a good template. I started a small hook to try and do this using DSPy prompt optimizers, but haven’t had a compelling use case to try it with.

This seems like an ideal case for trying DFT as well. I’m not sure if you’re using trl, but I’d suggest checking that out.

Surprising how badly Jetbrains implemented AI. Apparently to such an extent that even after multiple years of LLM's someone felt confident enough to build a company that can do better.

This looks really neat, interesting technical writeup as well!

Where is the training data?

We can't keep calling those models "open source" if we have a black box and know precisely how they were made.

"Open weights" are the new binary.

This is actually a game changer. I’ve been meaning to want to run models to accomplish exactly this, but don’t have enough VRAM on my GPU for the conventional LLM-method for the most part. This seems to be a far more efficient method of accomplishing a more scoped problem. Thank you for making it open source!

I've been trying my hands at implementing an emacs package for inline completions with this. I have it mostly working and performance is good enough but I haven't been blown away by the quality of its suggestions unfortunately. Which I guess is expected from a 1.5B model.

I'd love to see them making a larger model in the 10-20b range maybe? I know most people wouldn't be able to run that on their machines, but some could.

Running on ollama locally on NVIDIA Spark GB10. Tried it also with vLLM. Pretty fast.

It's good. The blog post about it is very interesting. I hope, a plugin for neovim will be made soon.

https://blog.sweep.dev/posts/oss-next-edit

There's also https://github.com/ggml-org/llama.vim

Which I've been using with Qwen3 Coder. As long as infill is supported, that should work. I'll try later today.

There is one already, on of the plugin authors commented here

[dead]

This is cool! I am more interested in how you guys generated next edit training data from repos, seems like there are lots of caveats here. Would love your insights

Again amazing work! waiting for what you guys cook next

I read the release but didn't quite understand the difference between a next-edit model and a FIM model - does anyone have a clear explanation of when to use one over the other? I'd love if there was a sublime plugin to utilize this model and try it out, might see if I can figure that out.

I’m going to speculate a bit here, FIM may stand for something-in-the-middle?

I know there are the original autocomplete models that simply complete the endings. Then there are Cursor like models capable of editing/filling text between blocks of code. In essence, they look at both the text before the insertion point and after it - then find the best fitting completion in the middle. My guess is FIM is the latter.

As you said. Fill-in-the-middle.

Is there a way to use this (or similar) model in Visual Studio? Extensions on Visual Studio Marketplace are clunky and sluggish at best, if they even work at all.

If you mean VSCode (or any other editor):

> We’re open sourcing the model weights so the community can build fast, privacy-preserving autocomplete for every IDE - VSCode, Neovim, Emacs, and beyond.

https://blog.sweep.dev/posts/oss-next-edit

No, I mean Visual Studio (the IDE), not Visual Studio Code (the editor).

Of course they are different products, but is there really a meaningful distinction between VS Code and an IDE? For all i care VS Code is a complete IDE.

You need to add (official) extensions for that though. Which makes VSCode more flexible

I thought there was already a generic plugin for this :(. Let's wait for one then ha, or I may just make one.

Hey, ollama run as suggested in hf doesn't seem to work with this model. This worked instead:

ollama pull hf.co/sweepai/sweep-next-edit-1.5B

I've been using it with the Zed editor and it works quite well! Congrats.

This kind of AI are the ones I like and I'm looking to run in my workstation.

Could you give the gist / config on how you made it work with Zed ?

+1, I wasn't able to make it work on zed either and It would really help if woile can tell how they made it work on their workstation.

This is so cool. What is the second order effect of model training becoming democratized? And local models becoming the norm? Tasks like agentic work are well handled by current AI as long as you know what you're doing and can stress the agent against tests/spec, etc.

I am thinking that one effect is:

- it will become normal for meta-models to train a model specific to a particular task/product.

Also, differently, I'm quite sure that AGI is not available on this current path (useful tho it is), but that some algo improvements might crack ubiquitous trainable AGI. Probably including some kind of embodiment to provide world-models and emotions (which are essential to embodied survival and success).

I'm playing around with this in LMStudio (in huggingface -> use this model dropdown -> LMStudio)

It's really impressive so far, so quick to respond on a mac mini M2. And it appears to be accurate at least for the obvious questions.

I couldn't get it to work as an autocomplete of Zed unfortunately. It looks like it's hardwired to work with some providers and LMStudio is not included in the prediction engines list. Has anyone got a work around?

I use Sweep’s Jetbrains autocomplete plugin daily, it really stands out.

Does it run totally offline?

Better than the one that ships with Jetbrains?

I did buy their $100/yr AI but its about to run out.

Definitely better. Next edit makes a difference. But it is not free, I think I pay $10/month.

It sounds like you might be killing Zed's ability to monetize, am I misunderstanding that?

If your only feature worth monetizing is replicated by a solo dev in his freetime you might have a problem.

not really though. The zed monetization seems to push towards selling tokens for full fledged models with good ide integration as a service. (They have let you run a custom tabcomplete for a little while)

Wow, I can even chat about C code with that model with LM Studio on my Macbook at 200 tokens per seconds

How easy is it to re-train these to specific subset of programming languages? Could there be a "ruby+rails+html" version, etc?

This seems great for code, but can this be used for non-code use cases?

Any easy way to try on vscode?

So SFT cost less only low hundreds of dollars? (1-10$ per hour per H100 if I'm seeing this correctly).

What about SFT?

Presumably basing this of Qwen is the reason it can be done for so cheap?

What type of hardware do I need to run a small model like this? I don't do Apple.

1.5B models can run on CPU inference at around 12 tokens per second if I remember correctly.

Ingesting multiple code files will take forever in prompt processing without a GPU though, tg will be the least of your worries. Especially when you don't append but change it in random places so caching doesn't work.

1.54GB model? You can run this on a raspberry pi.

Performance of LLM inference consists of two independent metrics - prompt processing (compute intensive) and token generation (bandwidth intensive). For autocomplete with 1.5B you can get away with abysmal 10 t/s token generation performance, but you'd want as fast as possible prompt processing, pi in incapable of.

if you mean on the new ai hat with npu and integrated 8gb memory, maybe.

Wow super fun read, I love how it went into the technical details. Any way to make it work with vscode?

Followed your work since the beginning and used it for inspiration for some cool demos on self-healing web scrapers. fascinating to see the transition from original concept to producing models. cool stuff.

I'm very green to this so forgive if this question sounds silly:

Would instead of the RL step a constrained decoding say via something like xgrammar fix syntax generation issue ?

> Would instead of the RL step a constrained decoding say via something like xgrammar fix syntax generation issue ?

It can, but you have to consider two things here:

a) constrained decoding ensures adherence to syntax, not semantics. Say you're editing a field in an enum in rust. You can write syntactically correct rust code that doesn't address the new field further in the code (say in a switch). You'd get correctly syntactic code, but the compiler will scream at you. RL works on both.

b) if your goal is to further train the model, so it works on many tasks, RL helps with exploring new paths and training the model further. Constrained grammars help with inference, but the model doesn't "learn" anything. With RL you can also have many reward functions at the same time. Say one that rewards good syntax, one that rewards "closing" all the functions so tree-sitter doesn't complain, and one that rewards 0 errors from the compiler. The model gets to train on all 3 at the same time.

Great! I have been trying to do something similar for Clojure.

This is a great resource to explore similar approach. https://blog.sweep.dev/posts/oss-next-edit

My notes so far https://kapilreddy.me/notes/2024/11/17/building-clojure-slm-...

Very interesting - and cool to read about the development process. I'd love to hear more about how genetic algorithm worked here.

I wonder whether we are perhaps the point of usefulness of 'next edit' code development in 2026 though.

what do people use for Neovim to integrate these models for tab-completion level of stuff. (i.e. non agentic/vibe coding)

I use llama.vim with llama.cpp and the qwen2.5-coder 7B model. Easily fits on a 16 GB GPU and is fast even on a tiny RTX 2000 card with 70 watts of power. Quality of completions is good enough for me, if I want something more sophisticated I use something like Codex

Congratulations on training a relatively small model that can beat larger models for this important task.

>We ran a genetic algorithm over 30+ diff formats

Can you you give more information about your genetic algorithm? Did you do crossover over the trained models (for example, ranking by fitness, take 20% most elite and create children by mixing their weights randomly)? Did you have a 'population size' (number of instances) for the genetic algorithms, and if so what was it?

Do you plan to release Sweep 3B/7B on HF?

Yeap, the two seems like game changer. For now, I'm using "Qwen2.5-Coder-7B". Sweep 1.5B is "just" 12 % point better than Qwen2.5-Coder, but Sweep 7B is 25% point better.

Does anyone know if the 7B model is also available somewhere?

is there any llm lsp it can integrate well with?

Really cool.

But how to use it instead of Copilot in VSCode ?

Run server with ollama, use Continue extension configured for ollama

I'd stay away from ollana, just use llama.cpp; it is more up date, better performing and more flexible.

Would love to know myself, I recall there was some plugin for VSCode that did next edits that accepted a custom model but I don't recall what it was now.

can it be integrated in monaco editor ?

[dead]

[dead]

[flagged]

You’re subtly pushing the same product in basically every one of your comments. If these are good faith comments please edit out the product name, it’s unnecessary and doing so as a green account just makes people consider you a spammer. Establish yourself first.

Or he could disclose it.l, which he did in a different comment on a different story.

I agree that green accounts could be regarded as suspicious and, if it were me, I'd disclose each time I mention it.

They've submitted "I'm working at io.net" quite openly, but I admit, they should at least announce their employment in the bio, otherwise it's a very poorly executed astroturf post (phrased like they're an experimenting user and not a dev).

> On the infra side, training a 1.5B model in ~4 hours on 8×H100 is impressive.

It's hard to compare without more details about the training process and the dataset, but, is it? Genuine question, because I had the opposite impression. Like, for example, recently I did a full finetuning run on a 3B model chewing through a 146k entry dataset (with 116k entries having reasoning traces, so they're not short) in 7 hours on a single RTX 6000.

Based on qwen2.5-coder? seems like a "why not/resume embellish/show VC" type release I guess

"Please don't post shallow dismissals, especially of other people's work. A good critical comment teaches us something."

https://news.ycombinator.com/newsguidelines.html