Case Converter
Convert text between snake, kebab, camel, and Pascal case.
How the case converter splits words
Every mode is derived from one word splitter, so snake_case, kebab-case and camelCase all break into the same words. The splitter recognises spaces, hyphens, underscores, dots and slashes, camel humps and letter/digit boundaries, and keeps an acronym run whole: HTTPServer becomes HTTP plus Server, so snake case gives http_server rather than h_t_t_p_server.
Eleven results are shown at once: lower, UPPER, Title, Sentence, camel, Pascal, snake, kebab, CONSTANT, dot and alternating. Title case keeps a short stop-word list (a, an, and, of, the, to and a few more) lower-case unless the word is first or last, and keeps an acronym you typed in capitals. Sentence case lower-cases the rest of the line and capitalises only its first letter, which is what a pasted paragraph usually needs. Alternating flips each letter in turn and leaves digits and punctuation where they are.
How to use it
Paste or type your text into the box. Every mode updates as you type, and each result has its own Copy button.
Worked example
Input:
the QUICK brown-fox_jumps over HTTPServer
Snake case returns the_quick_brown_fox_jumps_over_http_server, and Sentence case returns The quick brown-fox_jumps over httpserver.
Why it runs in your browser
The conversion happens on this page with JavaScript. Your text is not posted to a server, so the page works offline after it loads and nothing is retained anywhere.
Paste text and this page shows it in eleven cases at once: camelCase, snake_case, PascalCase, kebab-case, UPPERCASE, lowercase, Title Case, Sentence case, CONSTANT_CASE, dot.case and aLtErNaTiNg.
Each line is produced by the same shared `text.case` transform the converter rail uses, so word splitting is identical wherever a case is named on this site. An acronym run is kept together: `HTTPServer` splits into HTTP and Server, not H-T-T-P-Server.
Every card has its own copy button. Nothing is uploaded, and there is no download here — the output is meant to be pasted into code, not saved as a file.
How words are split, and why it matters
The splitter recognises separators, case changes and acronym runs. `the QUICK brown-fox_jumps over HTTPServer` becomes the words the, QUICK, brown, fox, jumps, over, HTTP, Server.
That is why snake_case gives `http_server` rather than `h_t_t_p_server`, and why CONSTANT_CASE keeps the acronym: `HTTP_SERVER`. Some tools split every capital and would produce a different answer for the same input.
Title Case uses a stop-word list, so `war and the peace` becomes `War and the Peace` rather than capitalising every word.
- Separators: space, hyphen, underscore and dot
- An acronym run stays one word
- Title Case lowers a mid-sentence stop word
The one input that silently fails
The shared engine refuses an input over 100 000 characters. On the converter rail that refusal is shown; here each card catches the failure and empties itself, so all eleven cards go blank with no message.
If the cards empty while the text is still in the box, the length is the first thing to check. Splitting the input into smaller pieces is the fix.
How to use the source box
Paste the text into the Input Text box. All eleven cases, camel, snake, Pascal, kebab, upper, lower, Title, Sentence, CONSTANT, dot and alternating, render at once from the same shared transform.
Copy the card you need with its own copy button. Acronym runs stay together, there is no download, and nothing is uploaded.
What to Expect
Best for
- Renaming an identifier into camel, snake, kebab or constant case
- Turning a shouted heading into sentence case
- Seeing all eleven variants of one phrase before choosing one
Not ideal for
- Input over 100 000 characters, where every card goes blank without an error
- Translating the words themselves, since only the letter case changes
- Reformatting a whole source file, which this page does not read
What this tool keeps
- Acronym runs, so HTTP stays together in every case
- Non-letter characters such as punctuation and digits
- One copy button per card, so only the variant you want is copied
What may need cleanup
- Words that were glued together in the source and cannot be split without a separator
- Title Case stop words, which you may want capitalised after all
- An empty card, which means the shared transform refused the input
Common errors
- Pasting a 150 000 character document and reading eleven blank cards as a bug in the page
- Expecting Title Case to capitalise every word including `and` and `the`
- Assuming alternate-letters mode ignores punctuation when counting
Example use cases
- Renaming a database column to camelCase
- Converting a JSON key to a shell environment variable name
- Checking how an acronym survives each case
Sample input
Paste the QUICK brown-fox_jumps over HTTPServer, then read the snake_case card.
Sample output
the_quick_brown_fox_jumps_over_http_server in the snake_case card, with HTTP kept as one word.
Who this is for
- Developers renaming identifiers
- Technical writers checking heading case
- Anyone who needs one phrase in several conventions at once
Frequently asked questions
Which cases does the case converter produce?
Eleven at once: camelCase, snake_case, PascalCase, kebab-case, UPPERCASE, lowercase, Title Case, Sentence case, CONSTANT_CASE, dot.case and aLtErNaTiNg.
Can it split words that were written without separators?
No. Words glued together in the source cannot be split without a separator, so the conversion keeps them as one word.
Why did every card go blank on a long input?
The shared transform refuses input over 100 000 characters, and every card goes blank without an error rather than half-converting it.
Build custom tools for your store
Join the SDK program to create useful ecommerce utilities for your store.