Case Converter
UPPERCASE, Title Case, camelCase, and more — with the actual rule each style follows.
This converts pasted text between several case styles: UPPERCASE, lowercase, Title Case, Sentence case, aLtErNaTiNg CaSe, camelCase, PascalCase, and snake_case. Each of these solves a different real problem — Title Case for headlines, camelCase for JavaScript variable names, snake_case for Python and database column names — and each follows genuinely different rules, not just a different visual style applied to the same logic.
Writers and developers reach for this tool for very different reasons on the same page: a blogger fixing a headline that got typed in all caps by accident, and a developer converting a written-out feature name into a valid variable identifier, are both solving a casing problem but with completely different correctness rules governing what the 'right' output looks like.
All nine case styles appear here as you type.
What each case style actually does
Title Case is the one people get wrong most often by hand: proper title case doesn't capitalize every word. Style guides (Chicago, AP, APA all differ slightly, but agree on the core rule) keep short articles ("a", "an", "the"), coordinating conjunctions ("and", "but", "or"), and short prepositions ("of", "in", "to", under about four letters) lowercase unless they're the first or last word of the title — so "The Lord of the Rings" keeps "of" and "the" lowercase, but "A Tale of Two Cities" capitalizes the leading "A" because it's the first word. This tool applies that convention automatically rather than naively capitalizing every word.
Sentence case capitalizes only the first letter of the first word (and any proper nouns, which the tool can't reliably detect automatically, so it's worth a manual check on names), lowercasing everything else — this is the convention for most body-text headings and is different from Title Case, which is reserved for actual titles.
camelCase and PascalCase are programming-identifier conventions, not prose styles: camelCase lowercases the first word and capitalizes the first letter of every subsequent word with no spaces or separators ("myVariableName"), used as the standard convention in JavaScript, Java, and several other languages for variable and function names. PascalCase is the same idea but also capitalizes the very first word ("MyClassName"), conventionally used for class/type names in those same languages. snake_case lowercases everything and replaces spaces with underscores ("my_variable_name"), the standard convention in Python and for most SQL/database column names.
aLtErNaTiNg CaSe (sometimes called "sarcasm case" or "spongebob case" from its internet-meme usage) simply alternates lowercase and uppercase letter by letter, ignoring word boundaries — it has no formal linguistic rule, it's purely a visual/meme effect.
Who uses this
- Fixing a headline typed in the wrong case convention before publishing, applying correct Title Case rules automatically.
- Converting a phrase into a valid camelCase or snake_case variable name for code, without manually retyping capitalization and separators.
- Standardizing inconsistent capitalization in a list of names or headings pasted from multiple sources.
Edge cases to know about
- Title Case can't reliably detect proper nouns that happen to be short prepositions or articles in another context (rare, but e.g. a title containing the word "Or" as part of a proper name) — always spot-check the output on titles with unusual capitalization needs.
- camelCase and snake_case conversion strips all punctuation and non-alphanumeric characters by default, since neither convention allows them in a valid identifier — if your source text has punctuation you need preserved, this tool isn't the right one for that.
- Sentence case lowercases proper nouns along with everything else, since the tool has no reliable way to detect which capitalized words in your original text were proper nouns versus just capitalized by convention — review the output for names that need re-capitalizing.
- aLtErNaTiNg case treats every letter as either an odd or even position and case-flips accordingly, ignoring spaces and punctuation entirely for the purposes of the alternation count — so a sentence with an unusual amount of punctuation can end up with the capitalization pattern landing differently than you'd expect from counting letters alone by eye.
Related tools
FAQ
- Why doesn't Title Case capitalize every word?
- Because that's not how English title-casing conventions actually work — major style guides (Chicago, AP, APA) all keep short articles, conjunctions, and prepositions lowercase in a title unless they start or end it. This tool follows that real convention rather than the common but incorrect "capitalize every single word" version.
- What's the difference between camelCase and PascalCase?
- Only the first letter: camelCase starts lowercase ("myVariable"), PascalCase starts uppercase ("MyClass"). In most programming style guides, camelCase is conventionally used for variables and functions, PascalCase for classes and types — the underlying rule for every word after the first is identical in both.
- Can I convert a sentence into snake_case for a database column name?
- Yes — that's exactly the use case snake_case conversion is built for. Spaces become underscores and everything is lowercased, punctuation is stripped, producing a valid identifier for SQL columns, Python variables, and similar contexts that don't allow spaces.
- Does converting to UPPERCASE or lowercase affect accented letters?
- Case conversion of accented Latin letters (like é/É or ñ/Ñ) is handled correctly — the accent is preserved and only the case changes, the same as it would for an unaccented letter. This differs from the slug converter's accent-stripping behavior, which is a separate, intentional transliteration step for URL safety, not part of case conversion itself.