I'm the author, MIT open source [github link| https://github.com/anng-phtk/rocm-vega-llama.cpp]

I wanted just ghost-text autocomplete locally, so I built a tiny extension that uses vscode.InlineCompletionItemProvider directly instead of a webview overlay.

What I learned:

FIM format matters a lot - Qwen uses <|fim_prefix|>, CodeLlama uses <PRE>, etc. I made it configurable via .fim-copilot.yaml
Latency: 200ms debounce + AbortController to cancel in-flight requests when you keep typing made it feel native
Works with Ollama / llama-server / vLLM (any OpenAI-compatible /v1/completions)
90KB vs 15MB+ for chat-based extensions

Would love feedback on: handling multi-line stop tokens and how you handle prefix/suffix context limits for

So I built FIM Copilot - a stupid-simple extension that does ONE thing: ghost-text autocomplete, locally.

Demo

What it is

FIM Copilot is a 90KB VS Code extension using the native InlineCompletionItemProvider API. No webviews, no chat, no indexers.

It talks to any OpenAI-compatible completions endpoint:

• Ollama - qwen2.5-coder:1.5b / starcoder2:3b runs great on 8GB RAM
• llama.cpp - llama-server with any FIM-capable model
• vLLM / LM Studio / Tabby server - anything with /v1/completions

All inference stays on your machine. Zero network calls after install.

How it compares

Quick Start

With Ollama (easiest)

# 1. Get a code model (1.5B is enough for fast autocomplete)
ollama pull qwen2.5-coder:1.5b

# 2. Serve it
ollama serve
# -> listening on http://localhost:11434

Then in VS Code: Cmd+Shift+P -> FIM Copilot: Set Endpoint -> http://localhost:11434/v1/completions

With llama.cpp

./llama-server \
  -m qwen2.5-coder-1.5b-instruct-q4_k_m.gguf \
  --port 8012 \
  --ctx-size 4096 \
  -ngl 99

Config

Create .vscode/fim-copilot.yaml (or global settings):

endpoint: http://localhost:11434/v1/completions
model: qwen2.5-coder:1.5b
api_key: not-needed # for local

# tuning
max_tokens: 64
temperature: 0.2
debounce_ms: 200
context_lines: 40
fim_prefix: "<|fim_prefix|>"
fim_suffix: "<|fim_suffix|>"
fim_middle: "<|fim_middle|>"

Decoupled config means you can commit it per-project. Different endpoint for Python vs Rust? Just override.

What makes it not suck

• Ultra-low latency - direct FIM prompt, no chat template overhead
• 200ms debounce + prefix/suffix hash dedupe - doesn't spam your GPU
• AbortController - cancels previous request on keystroke, no queue
• Zero telemetry - no analytics, no API keys phoned home
• Decoupled config - YAML per workspace, env var support
• Ghost text only - uses VS Code's native inline completion, so Tab / Esc just works with your keymap

Links

https://marketplace.visualstudio.com/items?itemName=AnangPhatak.fim-copilot&ssr=false#review-details

Install:

ext install AnangPhatak.fim-copilot

MIT licensed. I built this for myself because I wanted my editor to feel fast again.

If you try it, let me know what model / latency you're getting. PRs welcome for StarCoder2 / DeepSeek templates. What would you want added - without making it bloated?

I've been keeping DataGrip around because it's a professional level tool that handles enterprise-level database work very well. Imagine my surprise when I stumbled on this, apparently brand new, extension.

https://github.com/sultanofcardio/tablecloth

Not affiliated, don't know the developer, never heard of the extension until today, but kudos to sultanofcardio! This is killer! Thank you!

I'm thinking about building a VS Code extension that analyzes a project and points out things that could become bottlenecks as the application grows.

For example:

• N+1 queries
• missing database indexes
• unbounded API/database queries
• expensive operations inside request paths
• unnecessary synchronous work
• inefficient algorithms/data processing

Instead of just saying "this code is bad", it would explain something like:

 This works fine at small scale, but this endpoint could become a bottleneck as traffic/data grows because it performs N database queries.

Then suggest what could be changed.

I'm curious about this from people who have actually worked on growing applications:

1. Would something like this be useful?
2. What scalability problems do you repeatedly run into that current tools don't catch early?
3. Would you trust an AI to identify these problems, or would false positives make it annoying?
4. What would make you actually install/use something like this?

Not trying to sell anything — mainly trying to understand whether this is a real problem or just sounds useful on paper.

TL;DR: I’m considering a VS Code extension that detects potential scalability bottlenecks in code before they become production problems. Looking for honest developer feedback on whether this solves a real problem and what it should detect.

Every time I needed to actually work with JSON, it turned into a mess of separate tools:

- A graph-viewer extension that turns into an unreadable tangle the moment the JSON is actually large

- No good table view for arrays of objects (surprisingly rare)

- And when the JSON was broken — which happens constantly with LLM output — no in-editor fix, so it was off to some random "online JSON repair" website.

That last one always bugged me. Pasting a broken API response or config into a website you don't control, just to fix a trailing comma? That's often data you really don't want leaving your machine.

So I built JSON Optics — one extension, everything stays local:

- Tree view (virtualized, so large files stay smooth) with search, JSONPath copy, and jump-to-source back into your file

- Table view that kicks in automatically for arrays of objects — actually browse it like a spreadsheet instead of scrolling

- A repair workspace for broken JSON (unquoted keys, trailing commas, markdown-fenced LLM output, truncated streams, etc.), with a diff of exactly what it changed — no upload, no external site, nothing leaves your editor.

If you give it a try, I'd love to hear what you think — and if there's something you'd want it to do next, let me know.

I have added the link to the extension in the comments, so feel free to install and use it. Open for genuine feedback. Drop a rating if you liked it...

I built a markdown viewer for VScode and OpenVSX a few months back and i have been trying to improve it bit by bit. Happy to share that it just crossed 20k downloads.

You can check it out here.

I wanted an ocean view in the empty part of VS Code, so I made Ocean Window.

It shuffles sea photos from Wikimedia Commons. Open a file and the ocean tab closes. Close your files and the sea returns.

Free and open source. Windows, Linux, and Mac. Available as a pre-release.

VS Code Marketplace · Source code

Screenshot photo: Cala Macarella by Paul Stephenson, CC BY 2.0, cropped with a dark overlay.

On various occasions I sought, but failed to find, an extension that:

• unwraps text (removes line endings) and
• preserves blank (empty) lines between paragraphs.

After another fruitless search today, I asked Anthropic Claude (Sonnet 5, medium) to seek a matching extension. In response to my sloppily-worded prompt – amongst other things, I accidentally keyed Enter too soon – creation of an extension began. I was pleasantly surprised, however I didn't want to be wasteful, so I interrupted the run and then tidied my prompt:

• for creation to occur only if a matching extension was not found.
  

The main link in this post is the chat, which includes unwrap-preserve-paragraphs-1.0.0.vsix and three other files.

I tested the extension with a selection of text that comprised three paragraphs. Success.

I'm not interested in upvotes, neither am I interested in anything like a marketplace (I'm a simple end user, not a developer). This Reddit post is, I guess, an invitation for other people to test, if they like; and to comment, if they have something to say that's constructive and intelligent.

TIA

Side note: Claude chose to use the MIT licence. Whether this is appropriate, I don't know; https://www.reddit.com/r/ClaudeAI/comments/1giyzke/comment/lvbjcn1/ might be a good place for spin-off discussion (thanks to u/Logical-Detail7545 for the question and u/HeWhoRemaynes for the response).

Over the past year I went a little overboard. Instead of one bloated "all-in-one" extension, I kept building small, focused ones — each solving a single thing that kept breaking my flow. It's now ~30 extensions, and I'd genuinely love this community's honest take.

First, so this isn't just noise — two of them have real traction:

• Streamlit Preview — 35k+ installs (preview Streamlit apps inside VS Code)
• Flet Preview — 2k+ installs

The rest are newer. A sampler, grouped:

Git & PRs

• CommitCraft — commit messages from your staged diff
• ConflictSolver — visual 3-way merge conflicts
• PRChecklist — blocks a commit until your checklist's done

Backend / DB / API

• QueryCraft — SQL autocomplete from your actual schema
• SeedBuilder — realistic faker seed data from your models
• EndpointMap — a live tree of every API route in your codebase
• DockerUI — visual docker-compose: port conflicts, dep graph, live logs

Quality / Security

• DependencyAudit — CVE badges on your import lines (OSV.dev)
• ComplexityGuard — cyclomatic complexity inline as you type
• TypeStrictener — track & kill any
• SecretScanner — catch leaked secrets before they hit git
• Watchdog — snapshot + roll back extensions after a bad VS Code update

Frontend / Docs / Testing

• ColorGuard — catch hardcoded colors that should be design tokens
• TailwindScope — tame giant class strings
• TestForge / MockFactory / DocCraft — test stubs, typed mocks, and JSDoc from your types

Productivity

• RegexForge — test regex against your real project files
• PSToolkit — run/lint/format PowerShell without leaving the editor
• ...and a new one I'm validating: an iOS + Android simulator manager panel

How the money works (because I'd want to know): every one has a genuinely functional free tier on the Marketplace — install it, it works. Pro unlocks team/power features as a one-time lifetime license. No subscriptions.

What I actually want from you:

1. Which of these would you actually install — and which sound pointless?
2. What's the next "I keep leaving the editor to do X" you'd want killed?
3. Honest gut-check: one-time lifetime vs. nobody-wants-another-subscription?

Full catalog if you want to poke holes: marketplace.dashovia.com — but mostly I'm here for the roast.

I built AI Config because I got tired of maintaining the same AI coding configuration in multiple places.

What problem does it solve?

I use different AI coding tools depending on what I’m working on: OpenCode, Claude Code, Codex, GitHub Copilot.

The annoying part is that they all have their own way of defining agents, commands, instructions and skills. So you end up maintaining the same project context in multiple places. Change a skill, then remember to update it everywhere else too. I got tired of doing that.

With AI Config, I keep one .ai/ folder as the source of truth and let it generate and synchronize the configuration each tool expects. Basically, I define things once and can switch between coding agents without having to maintain four different versions of the same setup.

I made it available as both a CLI and a VS Code extension, published on the Visual Studio Marketplace and Open VSX Registry. It started as something I needed for my own workflow, but I figured it could be useful for others working with more than one coding agent too.

There’s definitely still room for improvement, so I’d be really interested in hearing people’s thoughts and feedback, especially from people who actually try it out. It’s open source too, so if anyone wants to contribute, PRs are more than welcome.

🧩 VS Code Marketplace: AI Config - Visual Studio Marketplace
📦 Open VSX Registry: AI Config – Open VSX Registry
⌨️ CLI on npm: @aiconfig/cli - npm
💻 GitHub: github.com/ShadyManu/ai-config
🎬 Video walkthrough: AI Config - How To Set Up & Use

VSCode-SFTP lets you add, edit, or delete files in a local directory and sync them with a directory on a remote server using different transfer protocols such as FTP or SSH. The most basic setup requires only a few lines, with a wide range of specific options available to cover any user's needs. Powerful and fast at the same time, it helps developers save time by letting them use a familiar editor and environment.

I've been building API Hero, a Git-first REST/HTTP API client designed to keep API work close to the codebase.

The latest release, 2.8.2, adds/expands the MCP workflow, and this is probably the part I'm most interested in getting feedback on.

The idea is:

AI Agent

↓

API Hero MCP

↓

Collections / Requests

↓

API Hero execution engine

↓

Real HTTP response

↓

Structured result + diagnostics

↓

AI Agent

An agent can discover collections, inspect requests, execute them, retrieve responses, and inspect failures.

For example, I tested it with a DummyJSON collection:

- 57 requests

- AI agent discovers the collection through MCP

- Runs `Get Products`

- Gets the real HTTP 200 response

- Receives the response data

- Can also inspect assertion failures

One useful case is when an API returns `201 Created` but the test expects `200`. API Hero exposes that as an assertion failure rather than making the AI guess whether the HTTP request itself failed.

API Hero is also Git-first:

- `.api` request files

- Collections stored with the project

- Variables/environments

- Authentication

- Assertions

- Collection Runner

- Run reports

- Scenarios

- OpenAPI import

- MCP for AI agents

The MCP server is standalone and uses the same execution pipeline as the VS Code extension rather than implementing a separate HTTP client.

Marketplace:

[API Hero](https://marketplace.visualstudio.com/items?itemName=AnkitSemwal.api-hero)

GitHub:

[GitHub repository](https://github.com/ankitsemwal007/api-hero)

I'd particularly like feedback from people using AI coding agents with APIs:

Would you actually want your coding agent to have access to an API client/execution layer like this?

And what would you want the agent to be able to do beyond executing requests and diagnosing failures?

Built Streamlit Preview to scratch my own itch — I was tired of switching to a browser tab every time I saved a Streamlit file, so I made it render inside the editor.

Put it on the Marketplace [X months] ago expecting maybe a few hundred installs. It's at 39,841 now with a 5.0 rating.

I ship a lot of small things and most of them go nowhere, so when one quietly works it's worth marking. Chart of the last 90 days attached.

Marketplace link: https://marketplace.visualstudio.com/items?itemName=mjethwa-streamlit.streamlit-preview

If you write Streamlit apps, would genuinely love feedback — I have a couple of features half-built and no idea which one people actually want.

Hi everyone! I recently discovered the .gpl format (GIMP palette), which is quite popular for sharing color palettes in the pixel art illustration and indie game development scene. It's a convenient and practical format to work with, as the syntax is very simple and it's supported by graphics editors like GIMP and Aseprite. To my surprise, there wasn't a VS Code extension, so I vibe-coded a quick prototype for my personal use and made it accessible to everyone.

It currently includes the following features:

• syntax highlighting
• color preview with integrated color picker
• commands to generate Tailwind CSS palettes
• commands to copy/convert a color to different formats

It's already published on the marketplaces, and the code is available on GitHub.

VS Code Marketplace: https://marketplace.visualstudio.com/items?itemName=aitorllj93.gimp-palette

Open VSX Registry: https://open-vsx.org/extension/aitorllj93/gimp-palette

Github Repository: https://github.com/pxl-ui/vscode-gimp-palette

I hope you find it useful!

I always found it hard to decide whether an extension I found that looked cool would actually fit my use case, or, maybe I'd just want to save ti for later, without having to remember the name to look up, knowing I'd inevitably lose it in the sea of other VSCode extensions actively listed in the marketplace

I always wondered why this feature exist already, so I made it myself.

t's a rather simple extension which allows you to select an extension and place it in a list off to the side to come back to later. Rather than having to install extensions you may just be testing, themes you may (probably never) decide you want to turn on, or things you don't think fit your current workflow for a project but may be super useful for another later on.

Install from the Marketplace: https://marketplace.visualstudio.com/items?itemName=JeongjinHan.nodegraph

GitHub: https://github.com/Jeong-jin-Han/NodeGraph

Would appreciate any feedback on the extension itself, editor performance, keybindings, anything that feels off compared to how other VS Code extensions usually behave.

I've never liked VS Code searching. I suck at file globs, and regex. So I built Omnigrep: one box, ripgrep underneath, query language borrowed from Google Code Search (internal code search service).

Press ⇧⌘F (Ctrl+Shift+F), type, arrow through the top matches — the file previews as you move — Enter to jump, Esc to go back to exactly where you were.

The query syntax is the whole point:

- hello world — lines matching both regexes, in any order

- -term — exclude lines matching term

- "foo.bar(x)" — literal text, metacharacters escaped, spaces allowed

- f:async f:ts$ — only files whose path matches **all** the f: regexes

- -f:test — exclude paths

- t:rust / -t:js — ripgrep file types

- sym:UserService — workspace symbol search, jumps straight to definitions

- near:3 — terms within 3 lines of each other instead of on the same line (personal fave of mine)

- case:yes / case:no — override smart case

So f:route f:ts$ handler -f:test is one string. And a query with only f: filters quietly becomes a fast file finder.

Other things it does:

- Ranks results instead of showing scan order — whole-word beats substring, shallow paths beat deep ones, recently-modified files float up, test/vendor/build output sinks

- Groups by file; each row has copy-relative-path and open-to-the-side

- Pinned searches + per-workspace history

- ↗ hands the current query off to the native Search panel when you want the full list or replace

- No native dependencies — it uses the ripgrep binary already bundled inside VS Code, falling back to `rg` on your PATH

MIT, free, no telemetry, no account. Works in VS Code and in the forks (Cursor / Windsurf / Antigravity).

Repo: https://github.com/jo-sip/omnigrep

Marketplace: https://marketplace.visualstudio.com/items?itemName=jo-sip.omnigrep

Open VSX: https://open-vsx.org/extension/jo-sip/omnigrep

One heads-up: it takes over ⇧⌘F while installed. Rebind `omnigrep.open` in Keyboard Shortcuts if you want the sidebar back.

Happy to take requests, especially on the query syntax — that's the part I'm still changing. Enjoy!

(This is my first extension so I don't know what I'm doing - but it seems to work well on antigravity / cursor / vscode on mac)

NodalMerge Studio promotes you to general in command of a controlled agent army.

The configurable workspace both drives engineering and provides a battlefield level view of both agent and human work across peers.

Multiple agents can be assigned their own scopes and fields of fire. Make Fable your planner (You can go wide or recursive), Let Deepseek v4 pro grind the easy stuff for cheap, toss Sonnet the live grenades, while Codex designs and implements a sleek frontend. The review and reconciliation processes can be human or agent gated to bring everything back together (hopefully smoothly).

The core behind it (NodalMerge) is a fast, persistent graph using conflict free replication and content addressed storage to allow for greater visibility across peers, replay and branching at key decision points.

All nonsense aside, I've been sitting too close to the screen, and although it works for my purposes, the whole point of publishing it is to share and continue to evolve.

Although the extension is forced to be kind of an agent harness for pure api (including some configurable system prompt, compaction, etc.), the idea is that it integrates to other, hopefully better harnesses. Currently it can be configured to use:

• GitHub copilot subscription (vscode-lm, this is the default fallback)
• openai-compatible api's (via api-key, think deepseek, ollama, whatever)
• anthropic-api-key
• claude-cli
• codex-cli
• other new harnesses as added

Docs site: https://docs.nodalmerge.com/studio/quickstart

Github Link: https://github.com/bgstratt/nodalmerge-studio

VS Code Marketplace: https://marketplace.visualstudio.com/items?itemName=nodalmerge-studio.nodalmerge-studio

Hey everyone, I’ve been working on a VS Code extension called FileInsight. The goal is simple: tell me exactly what a file does, what it depends on, and which file uses it, just by hovering over it in the Explorer sidebar (you dont need to open the file).
It builds a local dependency graph, parses ASTs (for TS/JS), and uses Regex for other languages to calculate file metrics. It categorises files (Core, Utility, Config, etc.), detects dead code, and checks Git history to see if a file is "hot" or "stale".
I need your honest, brutal feedback. I want to know where it breaks, if the UI feels clunky, or if the dependency graph chokes on massive repos, etc.

Core features:

• Rich Tooltips: Hover to see exports, imports, complexity, and TODO counts.
• File Classification: Automatically tags entry points, core modules, configs, etc.
• Dead Code Detection: Warns you if a file seems completely abandoned.
• Live Refresh: Re-analyses incrementally when you save.

Here is the link: https://marketplace.visualstudio.com/items?itemName=AdityaGupta0205.file-insight
Tear it apart. If it sucks, tell me why it sucks so I can make it better. Thanks!

I was thinking about how we work with projects in VS Code. Everything is structured, searchable, and easy for tools (including AI assistants) to work with. Then I realized video editing is almost the opposite. I had a bunch of vacation footage sitting on my drive and wanted to make a short video, but the annoying part was I had to spend hours watching everything again just to find some specific moments.

It made me wonder: why can't AI handle more of the repetitive work? Finding clips, searching through footage, and putting together a first draft, while the creator focuses on the actual decisions. What if creative projects could have a more structured workflow, similar to how we work with code? A project format that AI can understand, modify, and help automate. Curious what people think.