Case Converter

Paste a block of text above and this tool converts it to all nine cases at once, side by side, without touching what you typed. Nothing is destroyed and nothing is chosen for you — copy the one tile you actually need and the other eight, and your original, are still sitting right there. The rest of this guide is about picking the right one: which identifier convention a given language actually expects, and how to do the same job without leaving Word, Excel or Docs when a full page of results is more than you need.

Naming conventions: camelCase vs snake_case vs kebab-case vs PascalCase

The four "for code" tiles all solve the same problem — an identifier can't contain a space — by joining words together and marking word boundaries a different way. Which one is correct is not a style preference; it is set by the language or file format you're pasting into, and getting it wrong is usually a linter error rather than a matter of taste.

• camelCase — no separator, first word lowercase, every word after it capitalized: parseXmlHttpRequest. The standard for variables and function names in JavaScript, TypeScript and Java, and for property names in most JSON APIs written by a JS-first team.
• PascalCase (also called UpperCamelCase) — the same idea, but the first word is capitalized too: ParseXmlHttpRequest. Used for class names and type names across almost every C-family language — JavaScript, TypeScript, Java, C# — precisely so a reader can tell a type from a variable on sight without checking anything else. React and Vue component names follow this rule as well.
• snake_case — words joined with underscores, everything lowercase: parse_xml_http_request. The convention Python and Rust standardise on for variables and functions (PEP 8 makes it explicit for Python), and it's also how SQL column names and most environment variables are written, though environment variables are additionally shouted in full: PARSE_XML_HTTP_REQUEST.
• kebab-case — words joined with hyphens, everything lowercase: parse-xml-http-request. This is what a hyphen-based identifier looks like rather than a naming choice a program can act on directly — most languages don't allow a hyphen inside an identifier at all, because it would parse as subtraction. Where it does show up as the standard is CSS custom properties (--tool-accent-strong), HTML attributes (data-tool-id), URL slugs, and npm package names.

Two boundary cases are worth naming, because they're where a naive find-and-replace approach gets it wrong and this tool's code tokenizer exists specifically to handle them:

• A JSON API in one convention meeting a client in another. A common pattern is a backend that returns snake_case keys (many Python and Rails APIs do) consumed by a frontend that expects camelCase (idiomatic JavaScript). Converting field-by-field by hand invites a typo that only shows up at runtime as undefined; running each key through the camelCase tile above is the mechanical, checkable way to do the same conversion.
• Runs of capital letters, the acronym problem. parse XML-HTTP request is the hard case, because a naive converter that just deletes spaces and capitalizes on each one produces parseXMLHTTPRequest — technically readable, but not what any style guide asks for. The correct output is parseXmlHttpRequest, treating XML and HTTP as ordinary words rather than letter-by-letter acronyms once they're inside an identifier. That's exactly what the "For code" group does here: paste parse XML-HTTP request into the box and the four code tiles fold each capital run into a single word before rejoining it, rather than preserving every capital letter individually.

Sentence case converter

The Sentence case tile capitalizes the first word of each sentence and lowercases the rest of it, apart from words the tool already knows are mixed-case or an acronym — so iPhone and NASA survive inside an ordinary sentence untouched, the same as they do in Title Case (below). That protection steps aside on a fully shouted paste — see "Title Case converter" below for exactly when — which is what lets Sentence case actually fix a paragraph typed with Caps Lock stuck on rather than handing every short word back exactly as shouted: WHY IS MY CAPS LOCK STUCK ON comes back Why is my caps lock stuck on, not unchanged. It treats a line break as its own sentence boundary in addition to a period, question mark or exclamation point, specifically so a pasted list — one heading or bullet per line, often with no closing punctuation — comes out as several correctly-capitalized lines rather than one long run-on sentence with only the very first word capitalized. What it does not attempt is abbreviation detection: Mr. Smith reads as two sentences here, because getting that right needs a dictionary of abbreviations and every implementation that tries ends up wrong somewhere else instead. The failure is visible and a one-letter fix once you see it.

Title Case converter: AP, Chicago or every word

Title Case is the tile with a genuine judgment call built in, because there is no single agreed Title Case rule — style guides disagree on which short words stay lowercase. This tool ships three, selectable on the Title Case tile itself:

• AP (the default) capitalizes the first and last word always, capitalizes every word of four letters or more, and lowercases articles (a, an, the), coordinating conjunctions (and, but, or, for, nor, so, yet) and short prepositions of three letters or fewer (at, by, in, of, on, to, up, via) everywhere else. This is the rule most news and web writing follows, which is why it's the default.
• Chicago does the same but lowercases every preposition regardless of length — with, from, over, between and through all stay lowercase under Chicago where AP would capitalize them for being four letters or more.
• Every word capitalizes everything, no exceptions — including the, of and and.

Two protections apply before any style rule is even reached. Mixed-case words like iPhone and eBay are always emitted exactly as typed, in every one of the three styles and regardless of what position they land in — they carry a capital after their first letter and a lowercase letter of their own, so there's no ambiguity to resolve. Short acronyms — all capitals, five letters or fewer, like NASA, XML or USA — get the same treatment, but only inside text that's otherwise mixed-case. A longer all-caps run, like a shouted LAUNCHES, was never covered by that exception to begin with and comes down to Launches regardless, on the reasoning that a run past five letters reads as someone's Caps Lock rather than a genuine initialism.

The acronym exception switches off entirely, for words of any length, when the whole paste is shouted — every letter that has a case is uppercase, and there are two or more words. NASA launches a new rocket keeps NASA (AP gives NASA Launches a New Rocket), but NASA LAUNCHES A NEW ROCKET does not — every word is fixed, including the acronym, to Nasa Launches a New Rocket. That's the same trade Sentence case relies on (above) to actually correct a paragraph typed with Caps Lock stuck on, rather than leaving every short word shouting. The one cost worth knowing: a genuine all-caps list of initialisms — NASA API, or HTTP 404 NOT FOUND — looks identical to shouted text and gets lowercased the same way.

camelCase converter and PascalCase converter

Both live in the "For code" group and share the same tokenizer: text is split on whitespace, on punctuation, and on the boundary where a lowercase letter is followed by an uppercase one, with runs of capitals (like XML) folded into a single token rather than split letter by letter. camelCase then joins the tokens back together with no separator, lowercase first word, capitalized after: parseXmlHttpRequest. PascalCase does the identical join but capitalizes the first token too: ParseXmlHttpRequest. If the pasted text has nothing a code identifier could be built from — punctuation only, like !!! *** — the tile shows an em dash and a note rather than an empty box, and its Copy button is disabled, because there is genuinely nothing to copy.

snake case converter and kebab-case converter

Same tokenizer as camelCase and PascalCase, joined differently: snake_case lowercases every token and joins with underscores (parse_xml_http_request), kebab-case does the same with hyphens (parse-xml-http-request). Reach for snake_case for a Python variable, a Rust identifier, a SQL column name or an environment variable name in lowercase form; reach for kebab-case for a CSS custom property, an HTML data-* attribute, a URL slug or an npm package name. Both tiles are monospaced deliberately, so a developer reading the result off the screen sees it in the same face they'd see it in code.

Convert uppercase to lowercase in Word, Excel and Google Docs

The fastest fix for a one-off paragraph typed with Caps Lock stuck on lives in whichever app already has the text open, not in a browser tab:

• Microsoft Word has a dedicated shortcut for exactly this: select the text and press Shift+F3. It cycles through Sentence case, UPPERCASE and lowercase in that fixed order every time you press it, so from all caps one more press gives you lowercase and a second gives Sentence case. If you'd rather choose the target directly instead of cycling through it, use Format > Text > Change Case (or the Aa button on the Home ribbon in newer versions), which lists all five options including Capitalize Each Word and tOGGLE cASE.
• Excel has no keyboard shortcut for this at all, which is genuinely the most common reason someone leaves a spreadsheet and lands on a web converter. Instead there are three functions: =UPPER(A1), =LOWER(A1) and =PROPER(A1) (Excel's rough equivalent of Title Case — it capitalizes every word with no small-word or acronym exceptions, so NASA becomes Nasa). Each formula reads from another cell, so the usual workflow is a helper column: write the formula next to your data, copy the results, then Paste Special > Values back over the original column and delete the helper.
• Google Docs uses a menu instead of a shortcut: Format > Text > Capitalization, which offers lowercase, UPPERCASE and Capitalize Each Word.

Be honest about when this tool is and isn't the right move: for a single paragraph inside a document you already have open, the native shortcut in Word or the menu in Docs is faster than switching to a browser tab, pasting, copying a result and pasting it back. Where this page earns its place is everything none of those three tools do at all — camelCase, PascalCase, snake_case, kebab-case, or Title Case with a chosen style (AP versus Chicago) — and pasting text that needs several different cases at once rather than just one.

aLtErNaTiNg cAsE, and why it's here

The ninth tile is the meme case — aLtErNaTiNg cAsE, sometimes called "mocking case" or "spongebob case" — and it alternates by position, not by letter: every character in the input, including spaces, digits and punctuation, takes its turn in the count, starting lowercase at the first character. A character with no case of its own is emitted unchanged but still takes its turn, so the alternation carries straight across a word boundary instead of resetting there — hello world comes out hElLo wOrLd, with the w of world continuing on from the o right before the space rather than starting fresh at lowercase. One consequence worth knowing: feed the tile's own label back through the tile and you get the label back unchanged — aLtErNaTiNg cAsE in, aLtErNaTiNg cAsE out — which would not hold if the count reset at every space. It has no practical use beyond the joke it's making, and it stays on the page for the same reason the other eight do: it's a real, searched-for thing to want, and hiding it behind a second click would cost more than the tile does.