Google Docs ships with exactly four built-in capitalization choices — UPPERCASE, lowercase, Title Case, and Capitalize First Letter — all reachable from the Format > Text > Capitalization menu in any open document. For everyday writing that is enough: highlight a paragraph, pick a style, and Google Docs re-renders the text in place without breaking formatting or losing your links and lists. The limits show up the moment your task leaves standard prose. If you are cleaning up a column of variable names that arrived in mixed styles, turning a title into a URL slug, or rewriting API field names from JSON's camelCase to a database's snake_case, those four options do not help. There is no snake_case, camelCase, kebab-case, CONSTANT_CASE, or Sentence case anywhere inside Google Docs. Reaching for a separate tool is faster than rebuilding every name by hand, and the cleanest path is to paste once into the Case Converter, see every common variant side by side, then copy the version you need back into your document.
What Google Docs Can Do for Case Changes
The capitalization menu was added to Google Docs in 2022 and has not been expanded since. Open any document, click somewhere in the text, and look at Format → Text → Capitalization. You will see the same four entries on every Google account, in every region, on desktop and mobile:
- UPPERCASE — every letter becomes a capital letter.
- lowercase — every letter becomes a small letter.
- Title Case — the first letter of every word is capitalized.
- Capitalize First Letter — only the first letter of each sentence is capitalized.
Selection behavior is straightforward: highlight the range you want to change, choose one of the four, and the menu reapplies that style in place. Formatting like bold, italic, links, and list markers is preserved through the operation. There is no preview pane, no undo button inside the menu itself, and no way to apply two styles at once. If you want a Sentence-case version of the same paragraph, you have to run it through a separate pass after the Title Case conversion.
How to Change Case in Google Docs
The built-in route is short and works on every Google Docs account, on every browser, and inside the Android and iOS apps:
- Open the Google Docs document you want to edit.
- Select the text you want to change — a word, sentence, paragraph, or the whole document with Ctrl+A (Cmd+A on Mac).
- Click Format in the top menu bar.
- Hover over Text, then hover over Capitalization.
- Pick one of the four options: UPPERCASE, lowercase, Title Case, or Capitalize First Letter.
- Verify the change in your document. If it is wrong, press Ctrl+Z (Cmd+Z on Mac) immediately — Google Docs has a generous undo history that captures the entire conversion.
There is no keyboard shortcut, so the menu route is the only official path. For occasional cleanups inside a single document, this is genuinely all you need.
Where the Built-in Options Fall Short
The four built-in styles handle plain prose and the occasional headline. They fall down in three recurring situations that come up across writing, engineering, and editorial work:
- Naming conventions for code. JavaScript uses camelCase, Python and SQL use snake_case, CSS and URLs use kebab-case, and environment variables are usually CONSTANT_CASE. None of those four styles is exposed by Format → Text → Capitalization, so the menu cannot help.
- Acronym-heavy identifiers. HTMLParser reads as one word to a casual reader but two tokens to a tokenizer. Google Docs treats it as a single title-case unit, which leaves you with the wrong capitalization for most style guides.
- Batch conversion. If you have a column of fifty names that need to be re-cased into one consistent style, you cannot script that inside Google Docs. You have to paste them into a separate tool, convert them in one pass, and paste them back.
That gap is exactly what the Case Converter fills. It accepts any block of text, re-tokenizes it across spaces, underscores, hyphens, and casing boundaries, and produces ten variants at once — covering both writing styles (Title, Sentence, UPPER, lower) and the full set of programming naming conventions.
How to Use the Case Converter
The four-step loop works for every variant the tool exposes:
- Paste or type your text into the input box at the top of the Case Converter page.
- Look at the ten variants the tool generates instantly below the box — they all update at the same time as you type.
- Click Copy next to whichever version matches what you need; it goes straight to your clipboard.
- Switch back to your Google Docs document and paste the result with Ctrl+V (Cmd+V on Mac).
Because the conversion runs entirely in JavaScript inside your browser tab, you can disconnect from Wi-Fi and still get the same ten outputs on large pastes. Nothing is uploaded, so the tool is safe for drafts you would not put through a server, and the lack of a round trip is what makes it return instantly on large pastes.
Case Styles and When to Use Each
The ten variants are not interchangeable. Here is how each style maps to a real task:
| Style | Example | Typical use |
|---|---|---|
| UPPERCASE | HELLO WORLD | Headlines, emphasis, all-caps warnings |
| lowercase | hello world | Calming shouty text, casual social copy |
| Title Case | Hello World | Article titles, slide headings, book chapters |
| Sentence case | Hello world | Body paragraphs, UI labels, email bodies |
| camelCase | helloWorld | JavaScript and Java variables and functions |
| PascalCase | HelloWorld | Class names, React components, TypeScript types |
| snake_case | hello_world | Python and SQL variables, database columns |
| kebab-case | hello-world | URL slugs, CSS classes, file names |
| CONSTANT_CASE | HELLO_WORLD | Environment variables, compile-time constants |
| aLtErNaTiNg | hElLo WoRlD | Decorative social posts, playful accents |
The naming styles are syntactic rather than cosmetic: a single wrong capital in apiBaseUrl versus apibaseurl is enough to break a deployment. That is why hand-conversion is risky and why the re-tokenization inside the Case Converter matters when the input is messy.
How the Word-Boundary Detection Works
What makes the naming conversions reliable is the way the tool splits input. It does not just swap spaces for underscores and call the result snake_case. Instead, it re-tokenizes the input first, splitting on spaces, underscores, hyphens, and punctuation, and additionally detecting camelCase and PascalCase boundaries. That means a messy mix like fooBar_baz-qux is correctly understood as four separate words — foo, Bar, baz, qux — no matter which style it arrived in.
After tokenization, each word is normalized to a single canonical form before being re-cased in the target style. So a shouting SNAKE_CASE constant pasted in becomes clean camelCase rather than a broken hybrid, and an acronym-heavy HTMLParser identifier is split at the acronym boundary into HTML and Parser before being re-cased. Digits stay attached to their word, so order66 is treated as one token rather than being split into order and 66.
The alternating style works differently on purpose. It flips letters position by position and skips over spaces and punctuation, so the visual zig-zag lands only on the letters themselves. That makes the rule explicit and deterministic: the same input always produces the same output, which matters when you are scripting names or reformatting a column of data.
Common Real-World Uses
Here are the patterns that come up most often when readers paste text into a case converter from inside Google Docs:
- Fixing headline capitalization. A title typed in sentence case can be promoted to Title Case in one paste, or downgraded to Title Case from a writer who over-capitalized every word.
- Renaming variables to match a style guide. Pulling names from a document into a repo where camelCase is required.
- Converting API field names between JSON and a database. JSON speaks camelCase; most SQL databases want snake_case. Mapping them by hand is where typos sneak in.
- Turning a title into a URL slug. How to Change Case in Google Docs becomes how-to-change-case-in-google-docs, ready for a CMS or a static-site generator.
- Normalizing environment variable names to CONSTANT_CASE. Useful when copying config snippets from documentation into a .env file.
- Generating aLtErNaTiNg text for a bit of fun. Decorative social posts or playful accents in a casual email subject line.
Each of these is a single paste-and-copy in the Case Converter, and because the conversion runs locally, you can iterate through several variants without ever leaving Google Docs.
Limitations to Keep in Mind
The Case Converter works on the characters it can see. Numbers stay attached to the word they arrived with, and punctuation is treated as a separator rather than a letter.
Sentence case detection relies on the standard sentence terminators — periods, question marks, and exclamation points.