VS Code Extension Localization

Guidance for complete localization of Visual Studio Code extensions.

The VS Code Extension Localization skill comes from GitHub's official github/awesome-copilot repository. It helps teams and coding agents prepare the user-visible text of a Visual Studio Code extension systematically for multiple languages. According to the provider, the guidance distinguishes three resource types: localizable contributions declared in package.json, walkthrough content, and messages or other strings contained in JavaScript or TypeScript source code. Whenever a localizable resource is created or updated, the corresponding localization should be created or updated for every language currently supported by the extension. This skill is not an extension, a translation service, or an automated release tool. It is an editorial review aid that an agent can use while planning, implementing, and reviewing localization changes.

Why the classification matters

A VS Code extension can declare settings, commands, menus, views, welcome content, and walkthroughs through contribution points in package.json. According to the official VS Code documentation, these declarative texts are localized through language-specific package.nls files. The skill therefore directs attention to an exclusive package.nls file for each target language. That separation keeps localizable values distinct from extension logic and makes it clear during review which resource set belongs to which language. Exact file naming, supported language identifiers, and the contribution points used by a particular project must still be checked against the current VS Code reference and the extension's own package.json.

Walkthroughs and source code

Walkthrough steps are not simply more manifest values. The source describes dedicated Markdown files for walkthrough content, associated with the relevant step and language. An agent can use this distinction to check whether titles, descriptions, and explanatory text were translated together and whether references inside the extension still resolve. For messages and strings located in JavaScript or TypeScript source files, the provider names bundle.l10n files. This separation is useful because declarative metadata, editorial documentation, and runtime text have different change and testing paths. A translation that covers only visible menu labels therefore does not prove that an extension is fully localized.

A safe review workflow

Start by inventorying every user-visible string. Classify each occurrence as a manifest value, a walkthrough file, or a runtime string. Then verify which languages the project actually supports and update the appropriate resource set for every language. Check placeholders, contextual terms, keyboard shortcuts, markup, file paths, and technical identifiers for consistency. An agent should explain differences between source text and translations, but no language change should be accepted without diff review and tests. Open the extension in the intended VS Code versions afterward and inspect the Command Palette, settings, menus, views, walkthroughs, and error messages.

Boundaries and security

The skill does not edit files by itself and does not grant an agent additional permissions. A coding agent may still propose or apply changes to a worktree for a concrete task. Review those changes in a controlled environment, limit file access, and confirm external side effects. Translations can alter technical content as well: a translated configuration key, damaged placeholder, or changed escape sequence can cause runtime failures. Localization also does not replace accessibility review, extension tests, or manual inspection of the actual editor. GitHub identifies the underlying repository as MIT licensed, according to the provider. Current terms for GitHub, VS Code, and connected development environments are outside this skill and are not stated here as fixed prices.

Catalog classification

This entry belongs in Coding and suits agentic coding environments that can inspect repository files and explain changes. For exact file names, language identifiers, and supported contribution points, the official VS Code documentation remains authoritative. The skill is especially useful for review checklists, dividing work, and finding missing translation files. It does not decide whether wording is technically, legally, or culturally appropriate. Responsible developers must review target languages, product terminology, tests, and the presentation in a real VS Code installation.

Installation instructions

Purpose of the localization skill for VS Code extensions

The vscode-ext-localization skill comes from the awesome-copilot GitHub repository, which is maintained by GitHub itself and collects guidance for AI-assisted development tools. Per the provider, the skill helps localize every aspect of a VS Code extension, meaning making it available in different languages. It targets anyone who wants to localize new or existing contributed configuration such as settings, commands, menus, views, or walkthrough titles, as well as anyone who wants to translate string messages inside the extension's actual source code that are shown to end users. The skill is deliberately narrow and does not describe general translation theory, but the concrete technical conventions that Visual Studio Code prescribes for localized extensions.

The three localization paths in VS Code

According to the guidelines summarized in the skill file, Visual Studio Code has three separate mechanisms depending on where a piece of text to be translated originates. First, configuration items such as settings, commands, menus, views, and walkthrough titles that are defined in an extension's package.json file get translated via a dedicated file following the naming pattern package.nls.LANGID.json, for example package.nls.pt-br.json for Brazilian Portuguese. Second, walkthrough content that lives in its own Markdown files receives a language-specific copy following the same naming pattern, such as walkthrough/someStep.pt-br.md. Third, messages and string resources located directly in the extension's JavaScript or TypeScript source code that are visible to end users get translated via a bundle file named bundle.l10n.LANGID.json. This separation matters because a single translation process that only covers one of these three sources will automatically leave gaps in the other two.

Step 1: Prerequisites for using it

To make meaningful use of the skill you need an existing VS Code extension project with the usual folder structure, in particular a package.json file, and, where applicable, existing walkthrough files and source code containing visible text messages. The skill itself does not automatically translate content into a foreign language; it only prescribes the structure and convention according to which new or changed localizable resources must be added for every already-supported language. You therefore still need either human translators or an additional translation tool, which the skill merely guides you to apply consistently.

Workflow in practice

Whenever a new localizable resource is created, or an existing one changed, the skill requires that the corresponding translation also be created or updated for every currently available language. In practice this means: as soon as you add a new command or setting to package.json, the matching line has to be added to every existing package.nls.LANGID.json file. If a walkthrough text changes, the corresponding translated Markdown file has to be updated to match. And if a new user-facing message is inserted into the code, the corresponding entry has to appear in every bundle file. This consistent three-way synchronization prevents a situation where an extension shows up-to-date features in some languages but outdated or missing text in others.

Security, limitations, and value

Security considerations barely apply to this skill, since it works exclusively with text files inside your own project and touches no external services or sensitive data. The value lies mainly in the fact that developers don't have to research themselves which of the three localization mechanisms is responsible for which kind of text; the skill gives them that consistently. The limitations are obvious: the skill does no actual translation work and knows nothing about language-specific subtleties such as plural forms or cultural adaptation; it only ensures that the technical structure required for multilingual extensions is correctly followed. For actual translation quality, native-speaker review remains necessary regardless of the skill.

Free
Provider
GitHub
License
MIT
Last reviewed
09.09.2026

Repository and documentation

Categories

Compatible with

Claude Code Codex Cursor