Using Antigravity 2.x in Japanese — Five Layers for UI, AI Responses, and Prompts

Localizing Antigravity into Japanese is not a single setting. The classic confusion — "I chose Japanese in Settings, but the AI still replies in English" — happens because UI language and AI response language are configured separately.

As an indie developer maintaining the Dolice Labs sites in both Japanese and English, Antigravity is my daily tool — and once I understood how the layers split, the configuration guesswork disappeared.

This guide walks through localization as five layers — UI, AI responses, prompting, IME, and encoding — in the order you actually touch them.

First, Check Which Version You're On

Before the layers, one thing is worth confirming: where the Japanese UI setting lives changed between versions. When a set of steps you found online doesn't match your screen, this is usually why.

The awkward part is that new versions roll out in stages. A feature listed in the official release notes may not reach your install for a few days. So when "the setting in the guide isn't on my screen," suspect your version before you suspect the steps.

Layers 1 through 5 apply to every version — only the entry point in Layer 1 moves. If you're on 2.x, swap Layer 1 for the guide above and read on from Layer 2.

Layer 1: UI Language — Start with Settings → Language

There's only one thing to do right after installing: open Settings, set "Language" to Japanese (or your target language), and restart. Menus, dialogs, and button labels switch over.

This applies to Antigravity as a whole, not per project, so moving between projects won't mix languages.

On 2.x, as noted above, this splits into three settings: language pack, command palette, and AI response language. That also means you can localize the UI while leaving the command palette in English. I leave mine in English — I've memorized the command names in English, and translating them just makes them harder to find.

Layer 2: AI Response Language — Why the UI Is Japanese but Replies Are English

Switching the UI doesn't change the chat agent's response language — that's a separate setting. If replies stay in English, either set the response language to Japanese in settings, or add a line to your project's custom instructions: "Always respond in Japanese."

I prefer writing it into a project settings file, because the behavior survives switching machines and stays identical when a teammate clones the repo.

// Project custom instructions (example)
Always respond in Japanese.
Write all prose, plans, and comments in Japanese.
Keep variable names, function names, and commit messages in English.

That last line matters more than it looks. Once you steer responses toward Japanese, the model occasionally tries to write variable names and commit messages in Japanese too. Drawing an explicit line — "natural language in Japanese, code vocabulary in English" — keeps things stable.

When you want it everywhere, not per project

If you want the same behavior across every project, it's easier to set a global rule once than to repeat per-project instructions. Register "always respond in Japanese" as a global rule, and even freshly opened projects answer in Japanese from the first turn. Write project-specific instructions only when you need to override that.

In my own setup, the global rule fixes "prose in Japanese, code vocabulary in English," and only the projects where I draft the English version of an article override it with "respond in English here." Since adopting this two-tier approach, the response language stopped drifting as I move between languages.

Confirming Layer 2 took, on the spot

v2.2.1 added a built-in Guide skill that answers questions about Antigravity itself. It doubles nicely as a response-language check: ask it something in Japanese, like "tell me about Antigravity's agents." A Japanese answer means Layer 2 is wired up. An English one means the setting or the custom instruction hasn't taken yet.

It's a small thing — you don't need to make it write code to find out — but having a quick check right after changing a setting speeds up isolation.

Layer 3: Prompting in Japanese — Keep Technical Terms in English

Japanese prompts are plenty accurate, but how you write them changes the result. In rough order of impact for me:

First, specificity. "Create a button" gets you much less than "Create a React button that calls an API on click and shows a spinner while loading." This is true in English too, but Japanese tends to drop subjects and objects, so it's worth consciously filling them back in.

Second, don't force-translate technical terms. A mix — concepts in English, requirements in Japanese — communicates best, e.g. "a React component using Redux for state management." Replacing "Redux" or "state" with a Japanese rendering only blurs the intent.

Third, use bullet points once you have more than three requirements. Line-separated bullets are recognized one item at a time, so fewer requirements get dropped than when you string them into one long sentence.

Layer 4: Japanese IME Quirks

Antigravity works with the Windows IME, macOS Japanese input, and fcitx on Linux. Still, the in-progress conversion string and editor completion do occasionally collide. If pre-commit characters get stolen by tab completion or conversion gets garbled, the guide on fixing Japanese IME conversion issues has OS-by-OS fixes.

As a day-to-day precaution, when writing a long Japanese comment, confirming one phrase at a time tends to cause fewer problems than drafting it in a notes app and pasting it in — that's what I've found from heavy use.

Layer 5: Garbled Text and Unifying on UTF-8

Garbled Japanese is almost always caused by inconsistent file encoding. Dropping an .editorconfig at the project root that pins UTF-8 keeps everyone on the same state.

# .editorconfig
root = true

[*]
charset = utf-8

Especially in projects that carry Shift_JIS files brought over from an old Windows environment, the context breaks the moment the AI reads such a file — so align encoding before touching any localization settings.

When only some files garble, suspect that those files aren't actually UTF-8. On macOS or Linux the file command checks this quickly.

# Check encoding (look for anything other than UTF-8)
file -I src/*.ts
# → anything other than charset=utf-8 (shift_jis / iso-2022-jp, etc.) needs converting

If you find Shift_JIS files, convert them to UTF-8 in bulk with iconv so that both the AI and people read the same characters from then on.

iconv -f SHIFT_JIS -t UTF-8 legacy.ts -o legacy.utf8.ts

Terminal and Git — Two Places Japanese Garbles Outside the Settings

Even with all five layers in place, two spots can still garble. They sit outside the editor's settings screen, so localization guides tend to skip them.

And these two matter specifically once you hand work to an agent. Agents read terminal output to decide what to do next, so if git status comes back garbled, the agent reasons from the garbled version. Where a human would think "ah, mojibake" and read past it, an agent takes it at face value.

Git prints Japanese filenames as strings of digits

git status sometimes shows a Japanese filename as "\346\227\245\346\234\254\350\252\236.md". That's Git escaping non-ASCII by default. One setting stops it.

# Show Japanese filenames as-is
git config --global core.quotepath false

Pinning commit message and log encoding to UTF-8 keeps them readable across machines too.

git config --global i18n.commitEncoding utf-8
git config --global i18n.logOutputEncoding utf-8

Separately from core.quotepath, Japanese filenames also carry a subtler problem: macOS and Linux disagree on the actual byte sequence (they handle voiced sound marks differently). If agents failing to open a file or diffs showing up twice sounds familiar, when Japanese filenames become different things on macOS and Linux covers that one.

The Windows terminal isn't speaking UTF-8

The Windows command prompt doesn't default to a UTF-8 code page, so Japanese output breaks. To switch temporarily in the integrated terminal:

chcp 65001

On PowerShell, putting it in your profile saves typing it every time.

# Add to $PROFILE
[Console]::OutputEncoding = [System.Text.Encoding]::UTF8
$OutputEncoding = [System.Text.Encoding]::UTF8

macOS and Linux default to UTF-8, so you can mostly skip this section. One exception: if you SSH into an older server whose LANG is set to C, the same symptoms appear there.

Verifying the Setup Took Effect

Once the layers are configured, it's reassuring to confirm they actually took. I always check in this order.

First, are the UI menus in Japanese? You can see that at a glance. Second, ask the agent a single question — "what's your current response language?" A Japanese answer means the response layer is wired up. Third, write one line of Japanese comment, save, and reopen to confirm it doesn't garble. Fourth, create one file with a Japanese name and run git status on it to confirm it isn't reduced to a string of digits. With that, the foundation for a Japanese environment is in place.

When only the responses revert to English, it's usually the global setting from Layer 2 and a project instruction canceling each other out via an override. Temporarily removing the project-side instruction isolates which layer is responsible.

Symptom Quick Reference

A cheat sheet for guessing the cause first when you're stuck.

Japanese Comments Double as Context for the AI

Japanese comments in your code are read correctly by Antigravity. Beyond that, they work as context supply for the AI.

// Initialization when a user visits the page
const initializeApp = () => {
  // Load user settings from local storage
  const userSettings = localStorage.getItem('userSettings');
  // Fetch user info from the API
  fetchUserData();
};

Writing your intent in comments nudges the model's suggestions toward your requirements when you ask it to continue the implementation. In my projects I leave "why it's done this way" comments in Japanese, and both my future self and the AI end up leaning on them months later.

The settings work comes down to just three things: UI language, AI response language, and encoding. Terminal and Git only start to matter once you're handing real work to an agent, so they can wait. Lock those three first, then gradually bend your prompting toward your own style — that roundabout-looking path is, in my experience, the fastest way to a Japanese setup.