Case Converter

What this tool does

The Case Converter takes whatever text you paste in and rewrites it into one of seven cases: UPPERCASE, lowercase, Title Case, Sentence case, camelCase, snake_case, or kebab-case. There is no submit button. As soon as you type something, the converted output appears under a Result card, and a Copy button puts it on your clipboard. When the input is empty, the result card disappears entirely.

It is meant for the small but constant friction of converting between human-readable labels and machine-readable identifiers — turning User Login Form into userLoginForm for a variable, or get_user_name into Get User Name for a heading — without leaving the browser or opening an editor.

Who actually needs it

The tool is most useful when you find yourself shuttling between two worlds:

• Developers renaming variables, functions, database columns, environment variables, CSS classes, or API field names across snake_case (Python, Ruby, SQL), camelCase (JavaScript, Java, JSON), kebab-case (CSS, URLs, CLI flags) and SCREAMING_SNAKE_CASE constants.
• Writers and editors normalising headings, dropping a stray block of ALL CAPS back to title case, or fixing the case of a chunk pasted out of a PDF or screenshot.
• Content and SEO people generating slug-style identifiers, file names, or tag handles from longer phrases.
• Spreadsheet and CSV cleanup — converting a column of inconsistent labels into one consistent style before importing somewhere else.

If your need is a one-off conversion of a short string, this is faster than writing a script. For bulk file renaming or thousands of rows, you probably want a real script — but for the dozen times a day you want to flip a label, it is the path of least resistance.

How to use it

Type or paste your text into the Input Text box on the left. From the Convert To dropdown on the right, pick the case you want. The result appears under Result the instant either side changes, and the Copy button next to the output copies it via your browser's clipboard API.

That is the whole interaction. There is no batch mode, no per-line option, no settings panel. If you want to convert several pieces of text into the same case, paste them in one at a time — or paste them all in as one block and accept that the whole block will be treated as a single string (which matters for Sentence case and camelCase, both explained below).

How the conversion actually works

All seven cases run as plain string operations in your browser. Nothing is uploaded anywhere. Two of them work directly on the raw text without splitting it into words; the other five split first.

UPPERCASE applies JavaScript's toUpperCase() to the whole input. lowercase applies toLowerCase(). Neither one cares about word boundaries — they walk the string and re-case each letter.

Sentence case also operates on the raw text, with one rule: uppercase the very first character of the entire input, lowercase everything after it. It does not detect periods, exclamation marks, or question marks, so it will not capitalize the start of your second sentence. The input hello WORLD. goodbye becomes Hello world. goodbye.

The other four cases — Title, camelCase, snake_case, and kebab-case — all run the same word-splitting step first. That step does three things in order:

1. Inserts a space at every lowercase-to-uppercase letter transition (the regex /([a-z])([A-Z])/g). This is what lets the tool break apart text that is already in camelCase: helloWorld becomes hello World.
2. Replaces any run of underscores or hyphens with a single space (/[_-]+/g). So get_user_name and get-user-name both turn into get user name.
3. Trims surrounding whitespace and splits on runs of whitespace (/\s+/).

The resulting list of words then gets joined back together in whatever style you picked:

• Title Case: capitalize the first letter of each word, lowercase the rest, join with single spaces.
• camelCase: lowercase the first word entirely, capitalize the first letter of every later word and lowercase its tail, join with no separator.
• snake_case: lowercase every word, join with underscores.
• kebab-case: lowercase every word, join with hyphens.

A worked example

Say you paste in helloWorld_test-case 2. The word splitter:

• Inserts a space inside helloWorld at the o-W boundary, giving hello World_test-case 2.
• Collapses the _ and - into spaces, giving hello World test case 2.
• Splits on whitespace into five words: hello, World, test, case, 2.

From there you get:

• Title Case → Hello World Test Case 2
• camelCase → helloWorldTestCase2
• snake_case → hello_world_test_case_2
• kebab-case → hello-world-test-case-2
• UPPERCASE → HELLOWORLD_TEST-CASE 2 (original punctuation kept, no splitting)
• Sentence case → Helloworld_test-case 2 (only the very first character changes)

Common pitfalls

Sentence case is not multi-sentence aware. It capitalizes one character — the first one — and lowercases everything else. If you paste a paragraph, every sentence after the first will start with a lowercase letter. There is no fix inside this tool; you will need to repair those starts by hand or use a writing app that understands sentences.

Title Case ignores style guides. Every word's first letter is capitalized with no exceptions. AP, Chicago, MLA, and APA all keep short words like a, an, and, the, of, in, on lowercase unless they begin or end the title. This tool will give you The Lord Of The Rings, not the stylebook The Lord of the Rings. For editorial titles, use the linked Title Case Converter instead.

Acronyms get flattened. Anything that goes through the word-splitter has its tail lowercased, so NASA report becomes Nasa Report in Title Case and nasaReport in camelCase. If you need NASAReport, fix it by hand after the conversion.

Punctuation inside words stays put. The splitter only treats spaces, underscores, and hyphens as separators. A dot, slash, or apostrophe will not split a word. So user.name becomes User.name in Title Case (one word), and don't becomes Don't, not Don'T.

Already-uppercase camelCase confuses the splitter. The lowercase-to-uppercase rule means HTTPRequest reads as one word — there is no lowercase letter before R to trigger a break. You will get httprequest in snake_case rather than http_request. If you need http_request, type the input as httpRequest first.

Numbers and symbols pass through unchanged. Only letters get re-cased. Numbers do not start a new "word" for camelCase purposes either — v2 release becomes v2Release.

When not to use it

Reach for something else when:

• You need style-guide-correct headlines — keep the small words lowercase, capitalize the rest. Use a real title-case tool, not this one.
• You need to preserve acronyms like NASA, HTTP, SQL, iOS. This tool will normalise them away.
• You are renaming files or variables across a project. Use your editor's rename refactor or a script — converting one string at a time invites typos and missed references.
• You need locale-aware casing for Turkish, Azeri, or other languages with special I/i rules. JavaScript's default toUpperCase and toLowerCase follow Unicode defaults, which sometimes diverge from the locale-correct answer (the famous Turkish dotless-i is the textbook example).
• You need a URL slug. Kebab-case here is close, but a slug tool will also strip accents, drop punctuation, and collapse separators more aggressively. The linked Text to Slug tool is built for that.

Adjacent concepts worth knowing

SCREAMING_SNAKE_CASE (constants in C, Python, JavaScript) is not directly offered, but you can get it in two steps: convert to snake_case, then to UPPERCASE. PascalCase (class names in C#, Java, TypeScript) is not in the dropdown either; the closest is camelCase, then manually uppercase the first letter — or run Title Case and remove the spaces.

The four "machine" cases — camel, Pascal, snake, kebab — exist because different languages and contexts have different rules about what characters are legal in an identifier. URLs and CSS class names cannot contain spaces or underscores comfortably, hence kebab. Most database engines treat identifiers as case-insensitive, hence snake. JavaScript object keys are case-sensitive and forbid hyphens, hence camel. Knowing why each one exists makes it easier to remember which one a given context wants.

Privacy

Everything runs locally. The text you paste is held in the page's React state and transformed by JavaScript in your browser — there is no network request, no logging, and no analytics on the content. You can disconnect from the internet after the page has loaded and the tool still works.