Convert text into nine casing styles at once — uppercase, lowercase, title, sentence, camelCase, PascalCase, snake_case, kebab-case, and CONSTANT_CASE.
Content last reviewed
0 characters · 0 words
—
—
—
—
—
—
—
—
—
Type or paste into the input box — a sample phrase is available if you want to experiment first.
Every casing style converts live below the input, so you can compare them side by side.
Each card has its own copy button — click it to put that version on your clipboard.
A plain phrase converted into common identifier conventions.
Input
product launch checklistOutput
camelCase: productLaunchChecklist · PascalCase: ProductLaunchChecklist · snake_case: product_launch_checklist · CONSTANT_CASE: PRODUCT_LAUNCH_CHECKLISTSentence case lowercases everything, then capitalizes the start of each sentence. Note that proper nouns like Friday are not restored automatically.
Input
THIS IS URGENT. PLEASE REPLY BY FRIDAY.Output
This is urgent. Please reply by friday.Retyping a paragraph because the capitalization came out wrong — or renaming a variable by hand because the style guide wants snake_case — is busywork this tool removes. Type or paste once, and nine converted versions appear together: UPPERCASE, lowercase, Title Case, Sentence case, camelCase, PascalCase, snake_case, kebab-case, and CONSTANT_CASE.
Showing every style at the same time is the point. Writers can compare a Title Case heading with its sentence-case alternative before choosing; developers can grab the camelCase, kebab-case, and CONSTANT_CASE forms of the same phrase for a variable, a CSS class, and an environment variable without converting three times. Each card carries a short hint about where that style is conventionally used and its own copy button.
Conversion happens instantly in your browser — there is no convert button, no upload, and nothing stored. It is equally useful for fixing a sentence typed with Caps Lock on, normalizing messy spreadsheet values, and generating identifier names that match a codebase convention.
Type or paste your text into the input box. Click Try an example if you want to see the conversions with sample text first.
Look at the grid of cards below — all nine casing styles are generated live as you type, each labeled with a hint about its typical use (headlines, JavaScript variables, URLs, and so on).
Click the copy icon on the card you want. Only that version is copied.
Edit the input at any time; every card updates immediately.
Click Clear to reset and convert the next piece of text.
UPPERCASE, lowercase, Title Case, Sentence case, camelCase, PascalCase, snake_case, kebab-case, and CONSTANT_CASE are all generated from a single input.
Results update on every keystroke — there is no convert button to press.
Copy exactly the version you need without selecting text manually.
Each card notes where the style is conventionally used, such as env vars for CONSTANT_CASE or URLs and CSS classes for kebab-case.
Spaces, hyphens, and underscores in the input are treated as word boundaries when building camelCase, PascalCase, snake_case, kebab-case, and CONSTANT_CASE.
Convert a paragraph accidentally typed in capitals to lowercase or Sentence case instead of retyping it.
Compare Title Case and Sentence case versions of a headline before dropping it into a post or slide.
Turn a plain phrase into camelCase for JavaScript, snake_case for Python, kebab-case for CSS classes, or CONSTANT_CASE for environment variables.
Normalize inconsistently cased spreadsheet or database values to one predictable style.
Produce a kebab-case version of a title as the starting point for a URL slug.
Each card applies its own transformation to the same input, live in your browser.
., !, or ?._ or -.Numbers, punctuation other than the separators above, and symbols pass through unchanged.
Any typed or pasted text, from a single word to multiple paragraphs. Multi-line text is converted line by line within one output.
Fills the input with a sample phrase so you can preview all nine conversions.
Empties the input and resets every card.
Opens the input in a larger editor for long passages.
Title Case and Sentence case rewrite letter casing wholesale, so NASA becomes Nasa or nasa. Re-check acronyms and proper nouns after converting.
The identifier styles split on spaces, hyphens, and underscores only. Feeding productLaunchChecklist into snake_case returns productlaunchchecklist, because there are no separators to detect. Add spaces between words first.
This converter uses the simple convention where every word is capitalized, including a, of, and the. Publications that follow AP or Chicago style keep such words lowercase — adjust manually if your style guide requires it.
Title Case follows the simple capitalize-every-word convention rather than AP or Chicago rules, so short words like of and the are capitalized too. Sentence case cannot recognize proper nouns, acronyms, or the pronoun I — those need a manual pass afterward. The identifier styles (camelCase, snake_case, and friends) split only on spaces, hyphens, and underscores; they do not detect word boundaries inside existing camelCase text. Casing is applied with standard JavaScript string methods, which handle most Latin-script languages well but may not match locale-specific rules such as the Turkish dotless i.
All nine conversions are computed in your browser as you type. Nothing you enter is uploaded, stored, or logged by the tool, and there is no account or submit step.
Convert messy mixed-case text to lowercase first, then apply the style you actually want.
Re-check acronyms and proper nouns after using Title Case or Sentence case — NASA becomes Nasa.
Separate words with spaces before using the identifier styles; existing camelCase is not split automatically.
For headlines under a formal style guide, treat Title Case output as a starting point and lowercase minor words by hand.
Copy from the card you need rather than selecting text — each card copies only its own version.
For prose, prefer Sentence case for body copy and decide once whether headings use Title Case or Sentence case — mixing both on one page looks unedited. Avoid ALL CAPS for emphasis in body text; it reads as shouting and is harder for screen readers to convey well.
For code, match the convention of the ecosystem you are in: camelCase for JavaScript variables, PascalCase for class and component names, snake_case for Python and database columns, kebab-case for CSS classes and URL slugs, and CONSTANT_CASE for environment variables and constants. Converting the same phrase into each style from one input keeps related names consistent across layers of a project.
After any bulk conversion, skim the output for words that carry meaning through their capitalization — names, acronyms, trademarks — and restore them manually.
Conversions run client-side with plain JavaScript string operations: toUpperCase and toLowerCase for the simple styles, and regular expressions for the rest. Word boundaries for the identifier styles are runs of whitespace, hyphens, and underscores. Sentence boundaries are detected as ., !, or ? followed by whitespace. All nine outputs are recomputed on each keystroke; no text is transmitted or persisted.
| Style | Example output | Typical use |
|---|---|---|
| UPPERCASE | PRODUCT LAUNCH | Headlines, acronyms |
| lowercase | product launch | Normalizing text |
| Title Case | Product Launch | Headings, titles |
| Sentence case | Product launch | Body copy |
| camelCase | productLaunch | JavaScript variables |
| PascalCase | ProductLaunch | Class names |
| snake_case | product_launch | Python, databases |
| kebab-case | product-launch | URLs, CSS classes |
| CONSTANT_CASE | PRODUCT_LAUNCH | Env vars, constants |
Writers and editors fixing capitalization or formatting headings; developers generating identifier names that match a codebase convention; content and SEO teams building slugs and normalizing titles; and anyone dealing with data exports where the same value appears in three different casings. Because all styles appear at once, it also works as a quick reference for which convention looks right.
Title Case capitalizes the first letter of every word, which suits headings and titles. Sentence case capitalizes only the first word of each sentence, which suits body copy. Neither style preserves proper nouns automatically here, so re-check names after converting.
The simple styles change letter casing only — numbers, punctuation, and symbols pass through untouched. The identifier styles additionally replace spaces, hyphens, or underscores with the separator that style uses.
Not directly. The converter splits words on spaces, hyphens, and underscores, so it cannot see the boundaries inside productLaunchChecklist. Insert spaces between the words first and it will produce product_launch_checklist.
It follows the simple convention of capitalizing every word. Formal style guides such as AP keep minor words lowercase; if you follow one, lowercase those words manually after copying.
There is no fixed cap. Everything runs in your browser, so very large documents are limited only by your device — typical articles and pages convert instantly.
No. The conversions are computed locally in the page as you type, and nothing you enter is uploaded or saved.