Case Converter

Convert text to any case, all nine at once

Type or paste into the box and every supported case appears below it at the same time — not one result behind a dropdown you have to change and re-run, but nine results stacked on the page, each with its own Copy button. You see all the options side by side and take the one you want. Under the input box a live count shows characters, characters without spaces, words and lines, which is handy when the reason you are re-casing something is a length limit.

The conversion happens in your browser as you type. Nothing is sent anywhere, which matters more than it sounds for this particular tool: people paste customer names, unreleased product names, internal identifiers and draft copy into case converters all day. Load the page, go offline, keep working — it behaves identically, because there is no server involved.

Every case the tool produces

One phrase run through all nine conversions. The input is user profile image URL, chosen because it exposes the behaviours people get surprised by — an acronym, and four separate words.

The first four operate on your text as written, preserving punctuation and spacing. The last five rebuild the string from its words, which means punctuation is discarded — that is what makes them safe to paste straight into code.

It reads the case you already have, not just plain words

The interesting half of a case converter is not the output, it is the input parsing. This one splits text into words using four different signals at once:

• Whitespace — the obvious one.
• Underscores and hyphens, so snake_case and kebab-case input is understood as separate words rather than one long token.
• camelCase humps: a lowercase letter or digit followed by a capital marks a boundary, so userProfileImage splits into three words.
• Acronym boundaries: a run of capitals followed by a capital-then-lowercase marks a boundary, so HTTPServer splits into HTTP and Server rather than H, T, T, P, Server.

The practical consequence is that you can paste text that is already in some case and convert it to another. Drop parseHTTPResponse in and you get parse_http_response, parse-http-response and PARSE_HTTP_RESPONSE without touching it first. Drop in my-file_name 2 and the mixed separators are all handled: the programming cases come out as myFileName2, my_file_name_2 and my-file-name-2. That round-trip — one naming convention to another — is the single most common real reason people open this page.

What happens to acronyms

This is worth being blunt about, because it is where converters differ and where you may need to touch up the result. Word splitting recognises acronyms, but the programming-case builders capitalise the first letter of each word and lowercase the rest. So parseHTTPResponse becomes ParseHttpResponse in PascalCase, not ParseHTTPResponse. The URL in the table above comes out as Url for the same reason.

That is not a defect so much as a choice, and it happens to match the dominant style guidance for C# and Swift, which both prefer ParseHttpResponse and Url over screaming acronyms. Java and Go conventionally keep acronyms uppercase (parseHTTPResponse, URL). If you are writing in a language or codebase that prefers the uppercase form, copy the result and restore the acronym by hand — the tool has done the hard part, which is finding the word boundaries.

The four text cases behave differently again: UPPERCASE and lowercase simply transform every letter, so an acronym survives UPPERCASE and is flattened by lowercase. Title Case and Sentence case both lowercase the whole string first, so they will turn URL into Url and url respectively. If your text contains acronyms you want to keep, UPPERCASE and the raw input are the only paths that preserve them untouched.

Title Case is genuinely contested — here is what this tool does

Ask three style guides how to capitalise a headline and you get three answers. The tool applies the simple, predictable rule: capitalise the first letter of every word, lowercase everything else. Typographers call this start case. It is what you want for button labels, navigation items, table headers and product names, and it is what most software means by "Title Case".

What it is not is editorial title case as defined by AP, Chicago, MLA or APA, all of which keep certain short words lowercase unless they fall first or last in the title. The words those guides generally leave lowercase are:

• Articles: a, an, the
• Short coordinating conjunctions: and, but, or, nor, for, yet, so
• Short prepositions: at, by, in, of, on, to, up, via and similar
• to when it is part of an infinitive

So Chicago would set The Lord of the Rings, while this tool produces The Lord Of The Rings. The guides also disagree with each other about the cutoff — AP capitalises prepositions of four letters or more, Chicago traditionally lowercases prepositions regardless of length, and every guide capitalises the first and last word no matter what. Because there is no single correct answer, the tool does not guess: it gives you the mechanical version, which is right for interface text and one edit away from right for prose headlines. Fix the two or three little words by hand and you are done.

One more thing Title Case will not do: it cannot know that iphone should be iPhone or that mcdonald should be McDonald. Internal capitals in brand names and surnames are lost, because Title Case lowercases the string before capitalising the initials. Names like DeWitt, O'Brien and eBay all need a manual touch-up.

Sentence case

Sentence case lowercases the text, capitalises the first letter, and capitalises again after a full stop, question mark or exclamation mark followed by a space. Run the end. a new start? yes through it and you get The end. A new start? Yes — three sentences, three capitals, correctly.

It has the limits any purely mechanical version has. Proper nouns are not restored, because nothing in the string marks them: i met john in paris becomes I met john in paris only in the sense that the first word is capitalised — the standalone pronoun I and the names stay lowercase. And an abbreviation with an internal full stop, such as e.g. or Ph.D., will cause a capital at the next word if a space follows the dot. Sentence case is excellent for converting a shouty ALL-CAPS import into readable prose and for normalising headline-cased copy into body copy; it is not a proofreader.

Non-English text and the Turkish dotless i

Accented Latin characters are handled correctly by the four text cases, because they use the language-neutral Unicode case mappings built into the browser. café uppercases to CAFÉ with the accent intact; Greek, Cyrillic and other bicameral scripts map correctly too. Scripts without a case distinction — Chinese, Japanese, Korean, Arabic, Hebrew, Thai — pass through unchanged, as they should.

Two Unicode edge cases are worth knowing about because they surprise people:

• The German sharp s. Uppercasing straße yields STRASSE — one character becomes two, so the string gets longer. This is the standard Unicode mapping, not a bug, and it is irreversible: lowercasing STRASSE gives you strasse, not straße. Case conversion is not always a round trip.
• Turkish and Azerbaijani i. These languages have four i's: dotted i/İ and dotless ı/I. The correct Turkish mapping pairs i with İ and ı with I. The tool uses the default, locale-independent mapping instead, so dotless ı uppercases to plain I, and capital dotted İ lowercases to an i followed by a separate combining dot-above character — it looks right on screen but is two code points, not one, which can break an exact string comparison downstream.

The locale-independent behaviour is deliberate in most software, and it is the safe default: it means the same input always gives the same output regardless of whose machine runs it. The famous failure mode is the opposite — a system that applies Turkish rules by accident and lowercases ID to ıd, so a configuration key stops matching. But if you are working in Turkish text and need the linguistically correct result, check the i's by hand.

Converting between programming naming conventions

Most languages have a house style, and moving data between them means re-casing identifiers constantly. A rough map of where each convention dominates:

The everyday jobs this makes short work of: a Python API returns snake_case keys and your TypeScript client wants camelCase; a database column list needs to become a set of class properties; a list of feature names needs to become URL slugs; a config file needs its keys promoted to environment variables. Paste the whole list — the input box is multi-line, and the counts tell you how many lines you pasted — and copy the column you need.

One caveat when converting whole lists at once: the programming cases join all the words in the box, so a five-line list becomes one long identifier rather than five. For line-by-line conversion, do one item at a time, or convert the list and re-split. The four text cases — UPPERCASE, lowercase, Title Case, Sentence case — preserve line breaks, so they handle multi-line text as you would expect.

Practical notes

• Digits survive; punctuation does not. In the programming cases, digits are kept and treated as their own word if they stand apart, so order id 1234 becomes orderId1234. Colons, commas, apostrophes and everything else are dropped as word separators. If an apostrophe matters — don't — expect dont in the code cases, and use one of the text cases if you need it kept.
• An identifier cannot start with a digit in most languages, so if your text begins with a number, the camelCase and PascalCase results will need a prefix before they compile. The tool will not add one for you, because it has no way to know what you would want.
• Copy is per-result. Each block has its own button, so you never have to select text by hand or risk grabbing a stray space.
• Sample and Clear load a short example phrase and empty the box respectively, which is the fastest way to see what each conversion does before committing your own text.
• The counts update live and count what is in the input box, not the output — useful for checking a meta description or a character-limited field before you convert it.