Case Converter
Convert text between UPPERCASE, lowercase, Title Case, Sentence case, camelCase, PascalCase, snake_case, kebab-case and CONSTANT_CASE — free, instant, and works entirely in your browser.
Title Case capitalizes every whitespace-separated word — it does not lowercase minor words like "a" or "the" the way some style guides (AP, Chicago) do.
Sentence case treats a period, question mark or exclamation mark followed by whitespace as a sentence boundary, so abbreviations like "Mr." or "e.g." can occasionally produce an extra capital.
camelCase, PascalCase, snake_case, kebab-case and CONSTANT_CASE all split words the same way: on whitespace, on underscores/hyphens, and on lowercase-to-uppercase boundaries — so pasting an existing identifier converts it, rather than only working on plain sentences.
All nine case styles are computed live in your browser as you type — your text is never sent to our servers.
Paste an existing camelCase or snake_case identifier to convert it to a different style — the tool splits on case boundaries and underscores/hyphens, not just spaces.
Renaming a variable between JavaScript (camelCase) and Python (snake_case) conventions, or fixing inconsistent capitalization in a heading or title.
How it works
What a case converter actually does
A text case converter rewrites the same words into a different capitalization convention — without changing what the words are. That sounds trivial until you need to rename a JavaScript variable to match a Python file's convention, fix a heading that was typed in ALL CAPS by mistake, or turn a sentence into a CSS class name. This tool computes all nine common case styles from a single input, live, so you can pick the one you need without retyping anything.
The nine case styles
| Style | Example | Typically used for |
|---|---|---|
| UPPERCASE | HELLO WORLD | Emphasis, acronyms, constants in some languages |
| lowercase | hello world | URLs, file names, casual text |
| Title Case | Hello World | Headings, titles, book/movie names |
| Sentence case | Hello world | Ordinary prose, most UI copy |
| camelCase | helloWorld | JavaScript, Java and C# variable/function names |
| PascalCase | HelloWorld | JavaScript/Java/C# class and component names |
| snake_case | hello_world | Python and Ruby variable/function names, database columns |
| kebab-case | hello-world | URLs, HTML/CSS attributes, command-line flags |
| CONSTANT_CASE | HELLO_WORLD | Constants and environment variables in most languages |
Why programming languages disagree on case style
Each case style above is genuinely the dominant convention in its ecosystem, not an arbitrary choice:
- camelCase is the standard for variables and functions in JavaScript, TypeScript, Java, and C# — it reads naturally at the density those languages tend to use for identifiers.
- snake_case dominates Python and Ruby, and is also the near-universal convention for database column and table names, where underscores are more readable across tools that treat case differently.
- PascalCase (camelCase with the first letter also capitalized) is used for class names and, in modern frontend frameworks, component names — a visual signal that the identifier constructs something rather than holding a value.
- kebab-case is required by URLs and HTML attributes (which are case-insensitive, so
helloWorldandHELLOWORLDwould collide) and is the conventional style for command-line flags (--dry-run) and CSS class names in several popular style guides. - CONSTANT_CASE signals "this value never changes" — used for true constants and, almost universally, for environment variable names.
Mixing these up is not just cosmetic. A linter will flag a Python function named getUserName as violating PEP 8, and a CSS class named heroSection (rather than hero-section) will still work, but will look inconsistent next to every other class in a typical stylesheet.
Converting *between* identifier styles, not just from plain text
Most case converters only handle plain sentences — type words separated by spaces, get a different capitalization back. This tool also recognizes an existing identifier as input. Paste myVariableName and it correctly splits into my, variable, name by detecting the lowercase-to-uppercase boundary, then rebuilds that word list in whichever style you need. The same happens with my_variable_name or my-variable-name — underscores and hyphens are treated as word boundaries exactly like a space would be. That means renaming a variable when porting code between a camelCase language and a snake_case one is a single paste, not a manual find-and-replace.
Title Case and Sentence case are for prose, not identifiers
The other four styles — UPPERCASE, lowercase, Title Case and Sentence case — exist for ordinary writing rather than code. Title Case is common for headings and titles; this tool capitalizes every whitespace-separated word, which is the simplest and most predictable rule. Some published style guides (AP, Chicago) instead lowercase short "minor" words like *a*, *the*, *of* and *and* unless they start the title — if you need that specific nuance, this tool gets you most of the way there and you adjust the handful of minor words by hand.
Sentence case does the reverse: it lowercases everything, then capitalizes the very first letter and the first letter after any ., ! or ? followed by whitespace. This is a good heuristic and, like any heuristic, an imperfect one — an abbreviation such as *Mr.* or *e.g.* contains a period that does not actually end a sentence, so the letter immediately after it may get capitalized when it should not. Treat the sentence-case output as a strong first pass to proofread, not a guaranteed-correct rewrite, the same caveat that applies to sentence *counting* elsewhere on this site.
A quick reference for picking a style
If you are not sure which of the nine outputs to use, work backwards from where the text is going:
- Writing a UI label, error message, or paragraph? Sentence case.
- Writing a page title, book title, or heading? Title Case.
- Naming a JavaScript or Java variable/function? camelCase.
- Naming a JavaScript/Java class or a React/Vue component? PascalCase.
- Naming a Python or Ruby variable/function, or a database column? snake_case.
- Building a URL slug, HTML attribute, or CSS class? kebab-case.
- Naming a constant or an environment variable? CONSTANT_CASE.
Everything above runs the moment you type — nothing is uploaded, logged, or stored, so pasting a real variable name, a draft heading, or a config key is safe from this page's side.
FAQ
Does Title Case lowercase small words like "a" and "the"?
No — this tool capitalizes every whitespace-separated word, which is the simplest and most predictable rule. Some published style guides (AP, Chicago) instead lowercase short words like "a", "the", "of" and "and" unless they start the title. Use this output as a starting point and adjust those specific words by hand if you need that convention.
Why did Sentence case capitalize a letter in the middle of my text?
Sentence case treats a period, question mark or exclamation mark followed by whitespace as the start of a new sentence. Abbreviations such as "Mr.", "Dr." or "e.g." contain a period that does not actually end a sentence, so the next letter can be capitalized when it should not be. Proofread the output rather than treating it as guaranteed-correct.
Can I convert camelCase directly to snake_case?
Yes. Paste an existing identifier like myVariableName and every output updates — the tool detects the lowercase-to-uppercase boundary and splits it into words the same way it would split a sentence on spaces, then rebuilds it in whichever case style you need.
Does it work on snake_case or kebab-case input too?
Yes. Underscores and hyphens are treated as word boundaries exactly like a space, so my_variable_name and my-variable-name both convert correctly to camelCase, PascalCase, or any of the other seven styles.
What is the difference between camelCase and PascalCase?
Both join words with no separator and capitalize the start of every word after the first. camelCase leaves the very first letter lowercase (helloWorld); PascalCase capitalizes it too (HelloWorld). JavaScript and similar languages use camelCase for variables/functions and PascalCase for classes and components.
Why do some languages use snake_case and others camelCase?
It is convention rather than a technical requirement — Python and Ruby standardized on snake_case, while JavaScript, Java and C# standardized on camelCase for variables and functions. Following your language's dominant convention matters mainly for consistency: linters and style guides check for it, and mixed conventions in one codebase read as sloppy.
Why is kebab-case used in URLs instead of camelCase?
URLs and HTML attributes are case-insensitive, so helloWorld and HELLOWORLD would be treated as identical — camelCase's capitalization would be silently lost. kebab-case avoids that entirely by never relying on letter case to mark a word boundary, using a hyphen instead.
What is CONSTANT_CASE used for?
Signaling that a value is a true constant that never changes after it is defined — most languages' style guides use it for constants, and it is the near-universal convention for environment variable names (e.g. DATABASE_URL).
Is my text uploaded anywhere?
No. Every case conversion happens in your browser as you type. Nothing is uploaded, logged or stored, so pasting a real variable name, a draft heading or an unpublished piece of writing is safe from this page's side.
Does it count words and characters too?
Yes — word and character counts sit above the nine case results. Words are split the same way as the case conversions: on whitespace, underscores, hyphens, and camelCase boundaries.
What happens with punctuation or numbers in the text?
Punctuation attached to a word (like a comma or period) stays attached in Title Case, UPPERCASE and lowercase. For camelCase, PascalCase, snake_case, kebab-case and CONSTANT_CASE, only letters and digits are treated as part of a word — other punctuation is dropped when the text is split into words, matching how identifiers are written in real code.