Announcing Group Code v1.5.0: Favorites System for VSCode

I am excited to announce the release of Group Code v1.5.0, a major update to my Visual Studio Code extension that helps developers organize code by functionality rather than file structure. This release introduces the most requested feature: a favorites system that lets you mark important code groups for instant access.

What is Group Code?

Group Code is a VSCode extension I developed to solve a real problem I faced daily: navigating large codebases where related code is scattered across multiple directories. Instead of jumping between folders, you can create logical groups like “Authentication” or “Payment API” that collect all related files in one place, regardless of where they live in your project structure.

The extension has been available on the VSCode Marketplace and Open VSX Registry, and this v1.5.0 release brings major improvements based on user feedback.

What’s New in v1.5.0

Favorites System

The biggest new feature is the ability to mark code groups as favorites. When you favorite a group, it appears in a dedicated “Favorites” section at the top of the tree view for quick access. This is perfect for:

• Keeping your most-used code sections readily available
• Focusing on specific features you are currently working on
• Reducing time spent scrolling and searching

To use it, simply right-click any group and select “Toggle Favorite”, or click the star icon. The group immediately moves to the favorites section. When you favorite a parent group, all its child groups automatically become favorites too.

User Profile Storage

This was a critical architectural change. Previously, favorites were stored in the workspace folder, which caused merge conflicts when multiple developers worked on the same project. Now, your personal preferences are stored in your OS user profile:

• Windows: %USERPROFILE%\.groupcode\<workspace-hash>\
• macOS/Linux: ~/.groupcode/<workspace-hash>/

This means each developer on your team can have their own favorites without conflicts. The workspace’s .groupcode folder still contains the shared group definitions that everyone uses, but personal preferences stay separate.

Tree View State Persistence

The tree view now remembers which nodes you expanded or collapsed. When you restart VSCode, your tree returns to exactly how you left it. No more re-expanding nodes every time you open your project.

The state saves automatically with a 500ms debounce to avoid excessive disk writes while still feeling instant.

How to Get It

You can install or update Group Code in several ways:

From VSCode Marketplace

Search for “Group Code” in the Extensions view (Ctrl+Shift+X or Cmd+Shift+X), or visit the marketplace page.

From VSIX File

Download the VSIX from the GitHub releases page and install it via Command Palette: “Extensions: Install from VSIX…”

code --install-extension groupcode-1.5.0.vsix

From Open VSX

The extension is also available on Open VSX Registry for editors like VSCodium and Cursor.

Upgrading from Earlier Versions

If you are already using Group Code, the upgrade is seamless. Your existing code groups will continue working exactly as before. However, you will start with an empty favorites list since the storage location changed. Just mark your important groups as favorites again, and they will persist going forward.

There are no breaking changes. Everything is backward compatible.

Technical Details

For those interested in the implementation, here is how the favorites system works under the hood.

Storage Architecture

The extension uses MD5 hashing to create unique workspace identifiers. This ensures that favorites for different projects stay completely isolated, even if projects have similar names or paths.

// Workspace identification
const crypto = require('crypto');
const path = require('path');

function getWorkspaceHash(workspacePath) {
  const normalized = path.normalize(workspacePath);
  return crypto.createHash('md5').update(normalized).digest('hex');
}

Favorites are stored as a simple JSON file:

{
  "auth-module": true,
  "payment-api": true,
  "user-dashboard": true
}

Data Flow

graph LR
    A[VSCode Workspace] --> B[.groupcode/codegroups.json]
    A --> C[~/.groupcode/hash/favorites.json]
    A --> D[~/.groupcode/hash/treestate.json]
    
    B --> E[Shared Group Definitions]
    C --> F[Personal Favorites]
    D --> G[Tree Expansion State]
    
    E --> H[Team Git Repository]
    F --> I[Local User Profile]
    G --> I

The shared group definitions go in Git so your whole team sees the same code organization. Personal preferences stay local to avoid conflicts.

What Users Are Saying

The favorites feature was the most requested addition since the extension launched. I have been using it myself for the past few weeks in my own projects, and it has significantly improved my workflow when jumping between different parts of large codebases.

What’s Next

I am already working on the next release with features like:

• Quick search within favorites
• Keyboard shortcuts for common operations
• Export/import favorites across workspaces
• Integration with GitHub Copilot for smart group suggestions

If you have ideas or feature requests, please open an issue on the GitHub repository.

Feedback Welcome

I would love to hear your thoughts on this release. If you find bugs or have suggestions, please report them on GitHub. If you enjoy using Group Code, consider leaving a review on the VSCode Marketplace or starring the repository.

You can find me at:

• GitHub: @thechandanbhagat
• Website: chandanbhagat.com.np

Full Changelog

For complete details, check the full changelog on GitHub.

Thank you for using Group Code!

References

• Group Code GitHub Repository (https://github.com/thechandanbhagat/group-code)
• v1.5.0 Release Notes (https://github.com/thechandanbhagat/group-code/releases/tag/v1.5.0)
• VSCode Marketplace Listing (https://marketplace.visualstudio.com/items?itemName=thechandanbhagat.groupcode)
• Open VSX Registry Listing (https://open-vsx.org/extension/thechandanbhagat/groupcode)