Case Converters: Every Way to Change Letter Case

Twelve free case converters in your browser — from Title Case and Sentence case to camelCase, snake_case, and the meme-friendly aLtErNaTiNg cAsE — plus a plain-English guide to when each one is correct.

"Changing the case" sounds trivial, but two very different crowds care about it deeply. Writers and editors fight over Title Case rules, sentence-case headlines, and shouty ALL-CAPS. Programmers obsess over camelCase versus snake_case versus kebab-case because a single wrong convention can break a build, a database column, or a URL. This hub explains both worlds and links to a dedicated tool for every style.

In a hurry? Our all-in-one Case Converter performs all twelve conversions on a single screen — paste your text once, click the case you want, copy the result. Everything runs entirely in your browser; your text is never uploaded, logged, or stored. The sections below explain what each case is for so you pick the right one.

Writing cases

These are the cases editors, students, and content writers reach for. They are about readability and house style, not syntax.

UPPERCASE Converter

Makes every letter a capital. Our UPPERCASE Converter turns "hello world" into "HELLO WORLD" in one click — handy when caps lock failed you or when you need to bulk-shout a heading. Note that ALL CAPS reads roughly 10% slower than mixed case because readers lose the word-shape cues that lowercase ascenders and descenders provide.

When to use: acronyms, legal disclaimers, short labels and buttons, headings in styles that demand caps. Avoid it for body text or anything longer than a few words.

lowercase Converter

The opposite operation — every letter becomes small. Our lowercase Converter strips a string down to "hello world." This is the fastest way to normalise text that arrived in inconsistent or accidental capitals, or to chase a deliberately understated, lower-case aesthetic.

When to use: normalising data before comparison, casual or branded lower-case styling, cleaning up text someone typed with caps lock on.

Title Case Converter

Capitalises the important words in a heading. Our Title Case Converter turns "the war of the worlds" into "The War of the Worlds." The tricky part is the small words: most style guides leave articles (a, an, the), short conjunctions (and, but, or), and short prepositions (of, in, on, to) lowercase — unless one is the first or last word. AP style lowercases prepositions of three letters or fewer; Chicago style lowercases all prepositions regardless of length but still capitalises words like "Through" when used as adverbs. The two rule sets disagree often, so check which one your publication follows.

When to use: article and blog headlines, book and chapter titles, navigation labels, anything that wants to look like a published heading.

Sentence case Converter

Capitalises only the first letter of the sentence (and proper nouns), leaving the rest lowercase. Our Sentence case Converter turns "THE QUICK BROWN FOX" into "The quick brown fox." Sentence case has become the dominant style for UI text, modern headlines (used by Google, the BBC, and many product teams), and is easier to read than Title Case for long strings.

When to use: UI copy, modern web headlines, tooltips, email subject lines, and any heading where Title Case feels too formal.

Programming cases

These cases solve a hard constraint of code: identifiers usually cannot contain spaces. Each convention is a different way to glue multiple words into one token, and different languages and contexts expect different conventions.

camelCase Converter

Joins words with no spaces, lowercasing the first word and capitalising each word after it — the "hump" in the middle is the camel. Our camelCase Converter turns "user profile data" into "userProfileData." This is the default for variables and functions in JavaScript and Java, and for JSON keys in many APIs.

When to use: JavaScript and Java variables, function names, object properties, and JSON keys.

PascalCase Converter

Identical to camelCase except the first letter is also capitalised. Our PascalCase Converter turns "user profile data" into "UserProfileData." Also called UpperCamelCase, it is the universal convention for type names.

When to use: class, interface, and type names; C#/.NET methods and properties; React component names; enum members.

snake_case Converter

Lowercases everything and joins words with underscores. Our snake_case Converter turns "user profile data" into "user_profile_data." The underscore acts as a visible space, keeping multi-word identifiers readable without breaking the no-spaces rule.

When to use: Python and Ruby variables and functions, database table and column names, and many configuration and YAML keys.

kebab-case Converter

Like snake_case but joined with hyphens instead of underscores — the words look skewered like a kebab. Our kebab-case Converter turns "user profile data" into "user-profile-data." Hyphens are URL-safe and read naturally, which is why this dominates the web's front end.

When to use: CSS class names, HTML attributes, URL slugs, npm package names, and file names on the web.

CONSTANT_CASE Converter

Uppercases every letter and joins words with underscores — essentially SCREAMING_SNAKE_CASE. Our CONSTANT_CASE Converter turns "user profile data" into "USER_PROFILE_DATA." The shouty capitals signal "this value never changes" at a glance.

When to use: environment variables, named constants, enum values in C-family languages, and configuration flags.

dot.case Converter

Lowercases everything and joins words with dots. Our dot.case Converter turns "user profile data" into "user.profile.data." Dots imply hierarchy or namespacing, which is why nested config formats lean on them.

When to use: nested configuration keys (e.g. server.http.port), Java/.NET package and namespace paths, feature-flag names, and analytics event keys.

Transform cases

These don't follow a naming convention — they transform the case of existing letters for effect rather than for syntax.

Swap Case Converter

Inverts the case of every letter: capitals become lowercase and vice versa. Our Swap Case Converter turns "Hello World" into "hELLO wORLD." It is mostly a quick fix for text typed entirely with caps lock stuck on, or a playful styling trick.

When to use: rescuing text typed with the shift/caps state reversed, light stylistic effects, simple puzzles.

aLtErNaTiNg cAsE Converter

Alternates lower and upper case letter by letter. Our aLtErNaTiNg cAsE Converter turns "this is fine" into "tHiS iS fInE." Popularised by the "mocking SpongeBob" meme, it reads as sarcasm or ridicule online.

When to use: meme captions, sarcastic quote-backs in chats and social posts, and ironic emphasis. Not for anything you want taken seriously.

Case comparison table

Case style	Example ("user profile data")	Primary use
UPPERCASE	USER PROFILE DATA	Acronyms, labels, shouting
lowercase	user profile data	Normalising, casual styling
Title Case	User Profile Data	Headlines, titles
Sentence case	User profile data	UI copy, modern headlines
camelCase	userProfileData	JS/Java variables, JSON keys
PascalCase	UserProfileData	Class names, React components
snake_case	user_profile_data	Python/Ruby, DB columns
kebab-case	user-profile-data	CSS classes, URL slugs
CONSTANT_CASE	USER_PROFILE_DATA	Env vars, constants
dot.case	user.profile.data	Config keys, namespaces
Swap Case	uSER pROFILE dATA	Inverting existing case
aLtErNaTiNg	uSeR pRoFiLe dAtA	Sarcasm, memes

Frequently asked questions

What's the difference between camelCase and PascalCase?

Only the very first letter. Both join words with no spaces and capitalise the start of each subsequent word, but camelCase starts lowercase (userProfileData) while PascalCase starts uppercase (UserProfileData). By convention, camelCase is used for variables and functions, and PascalCase for types, classes, and components — so the capital letter alone often tells a reader whether they're looking at a value or a type.

Why do programmers use snake_case instead of just spaces?

Because most programming languages don't allow spaces inside an identifier — a space ends the token. To keep multi-word names readable without spaces, programmers substitute a separator: an underscore (snake_case), a hyphen (kebab-case), a dot (dot.case), or a capital letter (camelCase/PascalCase). snake_case is popular in Python and Ruby and for database columns because the underscore reads almost like a real space.

Does Title Case capitalise small words like "of" and "the"?

Usually not. Most style guides keep articles (a, an, the), coordinating conjunctions (and, but, or), and short prepositions (of, in, to) lowercase unless the word is first or last in the title. The exact list differs: AP style lowercases prepositions of three letters or fewer, while Chicago style lowercases all prepositions regardless of length. Our Title Case Converter handles the common small words for you.

What case should I use for a URL?

kebab-case (lowercase words joined by hyphens), for example /user-profile-data. Hyphens are URL-safe, easy to read, and search engines treat them as word separators — whereas underscores are sometimes treated as part of a single word. Avoid uppercase letters in URLs entirely, because many servers are case-sensitive and mixed-case paths cause duplicate-URL and broken-link problems.

Can I convert directly between two programming cases, like snake_case to camelCase?

Yes. The trick is that every case converter first splits your input back into individual words, then re-joins them in the target style. So you can paste user_profile_data straight into the camelCase Converter and get userProfileData — no need to add spaces yourself first. The all-in-one Case Converter makes this easiest: paste once, then click between styles.

Is there a difference between CONSTANT_CASE and snake_case?

Only the letter case. Both join words with underscores, but snake_case is all lowercase (max_retries) and CONSTANT_CASE is all uppercase (MAX_RETRIES). The uppercase version is a strong visual signal that the value is a fixed constant or an environment variable that shouldn't be reassigned at runtime.