Case Converter
Convert any text between 14 case styles — UPPERCASE, lowercase, Title Case, Sentence case, camelCase, PascalCase, snake_case, kebab-case, CONSTANT_CASE and more. Every style previews live as you type, with one-click copy or apply back to the input. Everything runs in your browser. Free, no signup.
How to Use This Tool
- Paste your text — type or paste into the box at the top, or press Sample to load a mixed-case example.
- Watch every style update live — all 14 case styles convert as you type, each showing its own character count.
- Copy the one you want — press Copy on any card to put that version straight on your clipboard.
- Or apply it back to the input — press Apply to input to overwrite your text with that style, then chain another conversion. Undo reverses the last change.
About Text Case Styles & When to Use Them
Case conventions look like a cosmetic detail, but in code they are load-bearing. Most languages and ecosystems have settled on a specific style for each kind of identifier, and breaking that convention makes code harder to scan even when it runs perfectly. JavaScript and Java use camelCase for variables and functions and PascalCase for classes and React components. Python uses snake_case for variables and functions, reserving PascalCase for classes. Environment variables and compile-time constants use CONSTANT_CASE almost everywhere. Converting between them by hand is tedious and error-prone, especially across a long list of names, which is exactly the sort of mechanical work a converter should absorb.
Outside code, the stakes are about clarity and consistency. URLs conventionally use kebab-case because hyphens are treated as word separators by search engines while underscores historically were not, so a slug like free-case-converter is more readable to both people and crawlers than the underscore version. CSS class names follow the same convention. File and folder naming benefits from kebab-case or snake_case simply because neither contains spaces, which avoids a whole category of escaping problems on the command line and in build scripts.
Title Case is the one style where reasonable people genuinely disagree, because the rules come from style guides rather than from software. The broad agreement is that you capitalise the first and last word and all the significant words in between, while leaving articles, coordinating conjunctions and short prepositions lowercase. The disagreement is about where the line sits: AP style lowercases prepositions of three letters or fewer, while Chicago lowercases them regardless of length. This tool follows the common overlap between the major guides, which suits headlines, page titles and marketing copy. If your organisation has a house style, treat the output as a fast first pass rather than gospel.
Sentence case deserves more attention than it usually gets, because it has quietly become the modern default for interface text. Google, Apple, Microsoft and most contemporary design systems all specify sentence case for buttons, labels, menu items and headings. The reasoning is that it reads faster, feels less shouty, and handles long strings and translated text more gracefully than Title Case, where every language has different capitalisation rules. If you are writing product UI rather than marketing headlines, sentence case is almost always the safer choice.
The genuinely difficult part of case conversion is not applying the case, it is working out where the words are in the first place. Converting HTMLParser, myVariableName-2024 and hello_world example into a clean word list means splitting on separators, detecting camelCase boundaries, handling runs of capitals, and separating digits from letters. This tool does all of that before it converts, which is why you can paste text in any existing style and get sensible output. Consistent naming across a codebase, a content library or a URL structure is one of those small disciplines that compounds — and when it needs to happen across hundreds of published pages at once, that is a content operations problem rather than a tooling one.
Pair this with our Find and Replace for bulk pattern edits, the Text Diff Tool to confirm exactly what a conversion changed, and the Word Counter for length checks.
Frequently Asked Questions
What is the difference between camelCase and PascalCase?
The only difference is the very first character. camelCase starts with a lowercase letter and capitalises each subsequent word, giving myVariableName. PascalCase, also called UpperCamelCase, capitalises the first word too, giving MyVariableName. The convention in most C-family and JavaScript codebases is camelCase for variables, function names and object properties, and PascalCase for classes, constructors, types, interfaces and React components. Python follows the same split, using snake_case where JavaScript uses camelCase but still using PascalCase for class names. Following the convention matters because experienced readers use the capitalisation as a signal about what kind of thing they are looking at.
What are the rules for Title Case?
The core rule is consistent across style guides: capitalise the first and last word, and capitalise every significant word in between, while leaving articles, coordinating conjunctions and short prepositions lowercase. Where guides differ is the cutoff. AP style lowercases prepositions of three letters or fewer but capitalises longer ones, so it writes "Through" but not "for". Chicago lowercases prepositions regardless of length unless they are the first or last word. APA capitalises words of four letters or more. This tool follows the common overlap between them, which works well for headlines and page titles. If you have a house style guide, use the output as a fast first pass and adjust.
When should I use snake_case instead of camelCase?
Follow the convention of whatever language or system you are writing for, since neither is objectively better. Python uses snake_case for variables, functions and module names, and PEP 8 makes that explicit. Ruby, Rust and most SQL dialects also favour snake_case. JavaScript, Java, C# and Go use camelCase for the equivalent identifiers. Database column names are commonly snake_case because many SQL engines fold unquoted identifiers to lowercase, which mangles camelCase. The practical rule is to match the surrounding code rather than your personal preference, because mixed conventions inside one codebase are worse than either convention applied consistently.
Why do URLs use kebab-case rather than underscores?
Mainly because search engines have historically treated hyphens as word separators and underscores as word joiners. A URL containing free-case-converter is read as three separate words, while free_case_converter has been treated as one long token. Google has said for years that hyphens are the recommended separator in URLs. Hyphens are also easier to read on screen, since an underscore can be hidden by the underline that browsers add to links. The same convention carries into CSS class names and file names in most front-end projects, which is why kebab-case dominates anywhere a name appears in a URL or a stylesheet.
What is CONSTANT_CASE used for?
It marks values that are fixed at compile time or configured outside the program. The two dominant uses are environment variables, such as DATABASE_URL or API_SECRET_KEY, and language-level constants, such as MAX_RETRY_COUNT. The all-caps styling is a visual signal to the reader that the value does not change at runtime and often comes from outside the file they are reading. In JavaScript the convention is usually reserved for genuinely fixed values rather than every const declaration, since const only prevents reassignment and is used constantly for ordinary variables.
Should interface text use Title Case or sentence case?
Sentence case is the modern default for product interfaces, and the major design systems from Google, Apple and Microsoft all specify it for buttons, labels, menu items and headings. It reads faster, has a less shouty tone, and handles long or translated strings far more gracefully, since capitalisation rules vary by language and Title Case does not translate cleanly. Title Case still suits marketing headlines, page titles, article headings and anywhere you want a more formal or promotional register. If you are unsure, sentence case is the safer choice for anything a user clicks and Title Case for anything they read as a headline.
How does the converter split words from mixed-style input?
It normalises the input before applying any case, which is what lets you paste text in any existing style. The splitter breaks on spaces, underscores, hyphens, dots and slashes, then detects camelCase boundaries by looking for a lowercase letter followed by an uppercase one. It also handles runs of capitals correctly, so HTMLParser becomes HTML Parser rather than H T M L Parser, and separates digits from letters so myVariableName-2024 splits cleanly. Punctuation is treated as a separator. The result is that converting from snake_case to camelCase, or from a messy mixed string to kebab-case, gives a sensible result without any manual cleanup.
Does converting case change my original text?
Not unless you ask it to. The previews are generated from a copy, so your input stays exactly as you typed it and you can compare all 14 styles side by side without committing to any of them. Pressing Copy puts a style on your clipboard without touching the input. Only Apply to input overwrites the box, and that action is pushed onto an undo stack that holds the last ten changes, so you can step back if you chain several conversions together. Your text is also saved to your own browser localStorage so a reload does not lose it, and nothing is ever uploaded.