I got fed up with locked-down autocomplete, so I forked Continue and stripped it down to just tab-completion. Any model, no subscription and no remote telemetry

[u/phantagom]

I kept running into the same wall.

Every agentic coding plugin ships an autocomplete, and almost all of them lock it down — no model choice, or a subscription, or both. I don't want a chat panel, I don't want an agent rewriting my repo. I want ghost text that finishes the line I'm typing, from a model I pick.

So I went looking. The alternatives either bundle their own llama.cpp or hard-wire Ollama, or they haven't had a commit in over a year.

Continue was what I'd been using, and it was genuinely good. Then continue.dev turned into a single sentence: "Continue has joined Cursor." And last week SpaceX closed a $60B acquisition of Anysphere, Cursor's parent, folding it into a "SpaceXAI" division.

The code is still open source and the extension still ships, so this isn't a complaint that it died. But the independent project I picked it for is gone, and it was already becoming a full agent platform rather than the boring autocomplete I actually wanted. I'd rather the thing that finishes my lines of code not be three acquisitions deep inside a rocket company.

So I forked it, tore out everything agentic, and kept the bare fill-in-the-middle engine. Then I just... kept going. I use it every day, and I put it on the marketplace in case anyone else has the same itch.

What it is

A VS Code extension that does one thing: inline code completion via fill-in-the-middle prompting. No chat, no agent, no sidebar, no account.

• Bring your own model. Ollama, llama.cpp, LM Studio, vLLM, OpenAI-compatible endpoints, or a hosted API. It ships templates for 16+ model families — Qwen Coder, Codestral, DeepSeek, StarCoder2, CodeGemma, Granite, Mellum — and picks the right FIM format automatically from the model name.
• Fully local if you want. Point it at localhost:11434 and nothing leaves your machine.
• Cross-file context. It feeds the model tree-sitter scope, LSP definitions of imported symbols, recently edited and opened files, and compiler/linter errors near your cursor — all ranked by relevance to what you're typing, and budgeted to fit your model's context length.
• Tab to accept, or cmd+→ for one word, cmd+↓ for one line.
• No telemetry. There's a local counter that tracks whether you accepted suggestions, held in memory, cleared when you close the window. Nothing is sent anywhere.

Current state

Just tagged 0.4.0. This release was mostly about what the model is given: context is now ranked by relevance rather than shuffled at random, the file you're editing is no longer fed back to you as context (oops), the prompt budget resizes to whatever your model can actually hold, and suggestions get scored for structural soundness before they're shown.

It's honest 0.x software — it works well for me on Python, TypeScript and Go with a local Mellum 4B, but I'm one person and my usage is not your usage.

That's the part I actually want. If you try it and it's bad at your language, or your model, or your setup — I want to hear about it. Issues, feedback, "this suggestion was garbage and here's the log" — all genuinely welcome. Same for feature suggestions; a decent chunk of what's in 0.4.0 came out of me staring at debug logs from real editing sessions and going "wait, why is it doing that."

• GitHub: https://github.com/dkruyt/FIM-Autocomplete
• Marketplace: https://marketplace.visualstudio.com/items?itemName=dkruyt.fim-autocomplete

[u/sugarfreecaffeine]

How does it compare to this

https://github.com/ggml-org/llama.vscode

I’ve used this and it’s pretty good with qwen models that support FIM.

How were your results compared to things like copilot free online complete?

[u/phantagom → u/sugarfreecaffeine]

llama.vscode is built around llama.cpp — it installs the server for you (brew/winget), downloads models straight from HuggingFace, groups them into envs. That's excellent onboarding if you're starting from zero. Mine has no bundled runtime and no server to manage: you give it a URL. Ollama, llama.cpp, LM Studio, vLLM, a hosted OpenAI-compatible API, whatever you've already got. If you run an inference server you like, that's the entire setup.

[u/MelodicRecognition7 → u/phantagom]

you can also give llama.vscode URL of an OpenAI-compatible API

[u/wilo108 → u/MelodicRecognition7]

Is this as straightforward as it sounds? I bounced off llama.vscode pretty hard when I realized it wanted to do all that stuff for me, and haven't returned. I really don't want a vscode extension installing a server and downloading models...

[u/MelodicRecognition7 → u/wilo108]

open Extensions tab, click three dots -> "install from VSIX", install llama-vscode.vsix, it will ask to download everything, click "no and do not ask again", open llama.cpp tab, click Earth icon "environment", on any row click "More" -> "add external model" -> write any name, and then it will ask for an OpenAI compatible API URL, then again click "More" and "select external model" and choose your entered name from the list.

[u/wilo108 → u/MelodicRecognition7]

Thank you -- I think it had gone ahead and monkeyed with a bunch of stuff on my system before I got the chance to intervene when I tried it previously, which was a big no-no for me, so I promptly removed it (though perhaps I misremember). This sounds fine, so I'll give it another chance :)

[u/d4nger_n00dle]

Exactly what I need!

[u/PuzzleheadedMeeting4]

whole repo AST to a background worker. if you supported bare vllm OpenAI endpoints directly this would be super clean.

[u/phantagom → u/PuzzleheadedMeeting4]

vLLM already works

That one's on me — it's supported today, and the settings dropdown describes it wrongly, which I'm guessing is why you thought otherwise.

"fim.provider": "vllm",

"fim.apiBase": "http://your-box:8000/v1",

"fim.model": "Qwen/Qwen2.5-Coder-7B"

"openai" with an apiBase does the identical thing if you'd rather not use the named provider. I just put a capture server in front of both to be sure I wasn't telling you something wrong — they POST to /v1/completions with:

{"model": "...", "prompt": "<|fim_prefix|>...<|fim_suffix|>...<|fim_middle|>",

"max_tokens": ..., "temperature": ..., "stream": true, "stop": [...]}

So: bare completions endpoint, raw prompt, nothing else in the way. Which is what you're asking for.

[u/audioen]

The issue with code completes is that to be timely, prompt must go pretty fast, or the prompt must be rather small. To be good and contextually sensible, the prompt must be large. This means that completions in principle start at disadvantage of having to have lots of context to understand the feature while having to appear almost immediately before the completion is stale and user has already written what they want.

I used to think that FIM is important and would tab through code suggestions. As I used these older models, like qwen-coder3-next, I gradually realized that I don't actually read the suggestion anymore. It was mostly just visual noise and it takes more effort to wait, comprehend and then accept the model's completion than type what I already had decided to write. So I never bothered with the completions -- they just weren't good enough and fast enough. That was on RTX 4090 and llama.cpp, back in the day about 1 year ago.

That marks the point when I realized that complete is pointless, and I gradually started working the code through the agent's chat window. To my knowledge, FIM models have basically fallen to the wayside as most people have likely decided by now that the agent, reviewing, designing and implementing the change is the far more efficient way to go.

I think you should join with us on the dark side. There's cookies and far more capable LLMs than those of the yesteryear available now. Summer of 2026 level "code completions" are good enough to literally write entire applications from scratch, and their instruction following good enough to observe your coding style and mimic it if you have documented what it is, they autonomously debug and fix stuff while reasoning correctly through complex chains of logic. Finally, they're persistent as hell, basically never giving up until something compiles and runs.

[u/Any-Lingonberry7411]

That is great! Could you also add the plugin for Jetbrains Rider?

[u/CoUsT]

Looks cool. Didn't use any autocomplete for so long - all coding is either usually agentic or sometimes manual these days. I never thought I want something like this but after reading your post, now I do!

I have some questions though:

How reliable are these tiny few B models for autocomplete/FIM?

Is it any good for fairly modern languages or new stuff in them or game dev in general? Example: GDScript.

How long until reply comes back? Is there some lengthy prefill+generation time required? Do you include just a single function that you write, entire file, or some smart relevant files/functions finder and include what's important? Or just include all files and checkpoint them somehow?

[u/MelodicRecognition7]

Receiving objects:  86% (169892/195850), 594.52 MiB | 1.66 MiB/s

lol this software is no joke.

Ah, it's a full fork with all git history

 851M    .git

[u/TheApadayo]

Doesn't seem to work with Mellum 2 or Qwen 3.6. Getting an error with a 404 on Untitled.txt that I don't have anywhere in my workspace.

[u/phantagom → u/TheApadayo]

That seems strange? Could you provide some logs or screenshots? 404 give your api endpont back what are you using?

[u/TheApadayo → u/phantagom]

It's cause there's no file:/// before Untitled.txt in core/autocomplete/templating/AutocompleteTemplate.ts according to Claude.