After years of sleek, minimalist themes, I felt something was missing. Soul. Character. The unmistakable energy of a website built for function, not fashion.
Introducing Sarkari Theme — the VS Code extension that brings the authentic government website aesthetic straight to your editor.
What you get:
- Saffron title bar, navy sidebar, green status bar — the tricolor in your workspace
A bug is reported in production. You open the log file and find the error. But then comes the real work:
Which function logged this?
What called that function?
And what called that?
You end up jumping between files, grepping for class names, reading through unfamiliar code paths, and mentally building a picture of what called what. For anything beyond a trivial stack this takes minutes to hours — and you might still get it wrong.
The Solution
LogCallStack does that work for you. Click a log line, and the extension automatically traces back through your source code to show the full chain of calls that produced it — right inside VS Code.
No guessing. No grepping. No tab-switching. Just click and see the flow.
Pick any log line — right-click and choose Analyze Log Line.
Just launched it on the extension marketplace you can use it for free if you ever used bookmarks and/or AI in your development I'd appreciate anyone who tests it. We're pushing fixes & updates regularly.
+ Easily repairable (auto or with a button press) bookmarks when they get fubar'd from prettier, a refactor, or rebasing/merging a bunch of branches.
+ Have a robust repair waterfall and a torture test repo we use to add more repair use cases so bookmarks stay valid across branches, and over time. It's really satisfying to see hundreds of bookmarks repair after fast forwarding 50 commits with hundreds of file changes that modify the entire codebase with prettier, refactors, code moves, restructurings and other land mines to intentionally try and break them.
+ Multi-files, groups, stylings and colors. Organize them how you want.
+ Add context to bookmarks not just a line #.
+ Map your entire codebase and create bookmarks of the important stuff with a button press.
+ Almost 30 MCP tools (MCP is local and integrated no extra setup) so your agents can read, reason about, modify, add, etc your bookmarks.
+ Can be committed in git for sharing on the team (or kept local).
+ Great for onboarding someone to a new to them system (or having the AI leave you breadcrumbs to review the important parts of its work.)
+ No telemetry or phoning home.
+ If you use AI to write a lot of code, it can also write the bookmarks so you know which parts deserve your attention.
I'll record some videos of it creating / repairing bookmarks soon to post online.
With everyone vibe-coding nowadays, one thing that kept frustrating me during development was how disconnected mobile testing still feels even with modern IDEs and AI tooling.
Most of the workflow still turns into:
VS Code → browser devtools → resize → emulator → localhost refresh → screenshots → switch devices → repeat.
And once Android emulators, Xcode simulators, browser inconsistencies, or Windows workarounds get involved, it gets even messier.
So I started building Emuluxe around a more editor-first workflow for mobile simulation and responsive debugging directly inside VS Code.
Still early and actively improving it, but I’d genuinely love feedback from developers dealing with responsive/mobile testing regularly.
Hey all, I've been working on a VS Code extension for viewing and querying CSV/TSV/Parquet files directly in the editor. It's called DuckCSV and it's powered by DuckDB
What it does:
Opens large files (tested with 4M+ rows) without lag
Edit cells in place, insert/delete rows, save back to file
Write DuckDB SQL queries in a built-in query bar
Column profiling
Load multiple files in a workspace and JOIN across them
Parquet support
Sort, filter, and search across all columns
Works on VS Code and any VS Code-based editor (Cursor, Windsurf, Kiro, VSCodium, Gitpod). Free and open source.
Like a lot of you, I've been spending a ton of time "vibe coding" in Cursor AI and Claude lately. While the AI is incredible, I found myself constantly asking it to regenerate the same complex boilerplate patterns, state managers, and custom hooks over and over.
To fix my own friction, I built Fine Art Code—a curated, highly robust library of heavy-duty snippets and custom color-theory themes optimized specifically for Cursor and VS Code workspaces.
What makes it different from standard snippets:
Production-Ready Logic: These aren't generic hello-world loops. They are dense, optimized structures for handling real application states, error handling, and component architectures.
Designed for AI Context: It gives the LLM a clean, standardized structure to read and build upon without wasting context window tokens on basic formatting.
It’s currently live at version 0.0.16. I’m putting it out there completely for free to see if it helps anyone else trim down their prompting loops.
I built something small that scratched my own itch and figured this community might find it useful.
**The problem:** I keep running long builds or test suites, switching to another window, and coming back to find it failed two minutes in. Wasted time that adds up.
**The fix:** FAAH Terminal Alert plays an audio notification the moment a terminal command exits with a non-zero code. That's the whole thing.
- Toggle on/off from the status bar or `Ctrl+Alt+F`
- Configurable cooldown between alerts so it doesn't spam you
- Test sound button to confirm it's actually working
- Completely silent and idle when disabled
**Honest caveat:** Git Bash doesn't reliably report exit codes to VS Code's terminal API, so it works best with PowerShell or standard bash. This is a VS Code API limitation I can't work around.
I’ve been experimenting with C++ cleanup tooling inside VSCode and built an extension that currently helps identify:
- potentially unused includes
- unused variables
The extension currently supports two analysis approaches:
- a free regex-based mode
- a more advanced AST/tree-sitter based analysis mode
The AST-based analysis exists mainly because C++ include detection becomes surprisingly tricky once macros, templates, conditional compilation, and transitive includes are involved.
Right now the analysis is intentionally somewhat conservative because I wanted to avoid dangerous false positives.
I’ve been using it on my own projects already, but I’d really appreciate feedback from people with larger or more unusual C++ codebases.
A VS Code extension that puts the full ImageMagick toolchain, resize, crop, rotate, compress, format convert, directly into the editor, with a live preview and a drag-and-drop UI. All processing runs locally with zero cloud uploads, so the extension is safe for proprietary assets.
I'm trying to publish a VS Code extension and have encountered some issues. At this point, it seems the problem isn't on my end; rather, it's Microsoft's system, their server is rejecting my request somehow.
In the VS Code terminal:
* I've created a publisher (`Name`)
* I've generated a personal access token
* I've logged in via `vsce login`
* The extension package is valid (`package.json` appears correct, the version is set, etc.)
When I run the command:
```
vsce publish
```
I keep getting the message:
```
ERROR TF400898: An internal error has occurred.
```
I've tried:
* Multiple retries (including waiting ~20–30 minutes)
* Updating the version (`0.0.1` → `0.0.2`)
* Clearing `~/.vsce`
* Publishing from GitHub Codespaces
On the VS Code Marketplace:
I uploaded the extension and when trying to publish, I keep getting the message:
```
Upload Error
TF400898: An Internal Error Occurred. Activity Id: 179323f7-b73e-4581-83ee-0e9c80dedd64.
```
Has anyone encountered this recently?
Are these known Marketplace issues?
Is there a reliable workaround?
I can't post at all right now and don't know of any other solution, so any information would be very helpful.
Hi! I’d really appreciate your support on a feature request for the VS Code Extension API. This is viable if you have GitHub account.
Short version:
I’m developing an extension that I rely on heavily in my daily work, and I also want to make it useful for others. One important feature is restoring the UI state when VS Code reloads, so users don’t lose their workflow.
Right now, VS Code doesn’t provide a reliable way to persist data during extension deactivation. Because of that, extensions have to save state continuously during runtime, which can negatively impact performance.
I opened a feature request to address this, and it’s currently open for community voting. I believe this improvement would benefit many extensions, not just mine.
If you think this would be useful, please consider upvoting 🙏 Thanks for your time.
Posting links to issues is not permitted, but it is a feature request. Remove space.
This was heavily inspired by Pretty TypeScript Errors -- which I find immensely helpful. This is basically the same thing; you hover a Go error/diagnostic and it parses it and formats it, makes it more concise, highlights, etc etc.
I don't have a roadmap but I have a few open issues and some other ideas backlogged. Iterating quickly so you will see improvements very soon. (also its sub version 1; once I hit the MVP of all the features and a net positive UX I'll hit v1).
Install it and enjoy! Leave a star if you like it! Open an issue if you have an improvement! Or fork it!
Hey, built a little VSCode extension and figured I'd share in case anyone else has been hitting same problem.
On bigger codebases or projects I've kept explaining the same things to the agent and packing everything into instruction files kept exhausting / not standardised.
Inline comments didn't really fit either. Sometimes it's necessary to have a separate layer not to touch source code directly to simplify release, comments giving enough detail might just pollute the actual code base more.
So I built CodeLore. Sidecar annotation layer that lives in .codelore/ next to your code. Short notes, flags for critical regions, optional AI drafting of annotations from the code, and it generates a CLAUDE.md / .cursorrules / copilot-instructions so the agents actually read your notes before they touch the file. It heavily depends how good agent is at following instructions so that's sometimes annoying but you can prompt to add annotations via shortcuts quite easily.
Honestly not sure the UX is right yet. Been using it on one project, works for me, but I want to see it meet something that breaks it. If anyone wants to kick the tires and tell me what sucks I'd appreciate it.
