# Case converter: eleven modes and their edge cases

> What each mode really does to your text, including title case, sentence case, programming cases, accented letters and the characters whose length changes.

- Tool: [Case Converter](https://toolsg.com/en/case-converter)
- Language: en (available: en, zh, ms, ta)
- Last verified against official sources: 2026-10-20
- Source site: ToolSG — a planning guide, not official or financial advice. Cite the agencies listed under Sources.

## Key figures at a glance

| Fact | Value | Source |
| --- | --- | --- |
| Modes | Eleven — lower, upper, title, sentence, camel, pascal, snake, kebab, constant, alternating, inverse. |  |
| Programming cases | Split on spaces, - _ . / \, lower-to-upper joins and acronym runs — Punctuation such as commas is not removed. |  |
| Title case | Capitalises every word — There is no small-word exception list: 'of' and 'the' are capitalised too. |  |
| Casing rules | Unicode default, not locale-aware — ß becomes SS in upper case, and İ lowercases to i plus a combining dot. |  |

## What each mode does

The tool applies one mode at a time to the whole text and updates the result as you type. Nothing is sent anywhere.

| Mode | Rule |
| --- | --- |
| lower / upper | JavaScript `toLowerCase()` / `toUpperCase()` on the full text. |
| Title Case | The first letter of every run of letters becomes upper case and the rest lower case. An apostrophe inside a word does not start a new word. |
| Sentence case | Lowercases everything except words already in ALL CAPS (2+ letters) when the text also has lower-case letters, then capitalises the first letter of the text and the first letter after `.`, `!` or `?` followed by whitespace. |
| camelCase / PascalCase | Splits into words, lowercases each, then capitalises the first letter of each word (camelCase leaves the first word lower case) and joins them. |
| snake_case / kebab-case / CONSTANT_CASE | Splits into words and joins with `_` or `-`, in lower or upper case. |
| aLtErNaTiNg | Lower case for the first, third, fifth character and so on, upper case for the others. Spaces and punctuation count as characters. |
| iNVERSE | Swaps each letter's case. |

For the programming modes, "words" are separated by whitespace, hyphens, underscores, dots, slashes and backslashes, by a lowercase letter or digit immediately followed by a capital, and at the end of a run of capitals that is followed by a capitalised word (`HTMLString` splits into `HTML` and `String`).

## Worked example

Input: `the quick brown FOX, it's 3 o'clock. isn't it?`

| Mode | Result |
| --- | --- |
| Title Case | `The Quick Brown Fox, It's 3 O'clock. Isn't It?` |
| Sentence case | `The quick brown FOX, it's 3 o'clock. Isn't it?` |
| camelCase | `theQuickBrownFox,It's3O'clockIsn'tIt?` |
| snake_case | `the_quick_brown_fox,_it's_3_o'clock_isn't_it?` |
| CONSTANT_CASE | `THE_QUICK_BROWN_FOX,_IT'S_3_O'CLOCK_ISN'T_IT?` |
| iNVERSE | `THE QUICK BROWN fox, IT'S 3 O'CLOCK. ISN'T IT?` |

The programming modes keep the comma, apostrophes and question mark. Clean the text first, or remove punctuation afterwards, if you want a valid identifier.

## Edge cases

- **Acronyms inside identifiers.** `parseHTMLString` becomes `parse_html_string`, `XMLHttpRequest` becomes `xml_http_request`, `getHTTPResponseCode` becomes `get_http_response_code` and `userID` becomes `user_id`. A run of capitals followed by a capitalised word is split before its last capital. In camelCase and PascalCase the acronym is re-cased like any other word: `parseHTMLString` gives `parseHtmlString`. A name that is entirely capitals (`USER`) stays one word.
- **Sentence case keeps ALL-CAPS words only in mixed-case text.** `NASA launched. i agree` becomes `NASA launched. I agree`, and `the quick brown FOX` keeps `FOX`. If the whole text is upper case, nothing separates an acronym from shouting, so everything is lowered: `HELLO WORLD. NASA IS HERE.` becomes `Hello world. Nasa is here.` Acronyms written in lower case (`nasa`) are not raised, and abbreviations such as `Dr.` are treated as sentence ends, so `Dr. smith` becomes `Dr. Smith`. Only the first letter after a terminator is raised; a new line alone does not start a sentence.
- **Length can change.** Full Unicode case mapping turns `ß` into `SS` in upper case (`Straße` gives `STRASSE`), per Unicode's SpecialCasing.txt. Because of this, upper then lower does not always return the original.
- **No Turkish rules.** `İstanbul` lowercases to `i` plus a combining dot above (two code points) because the tool does not apply locale-specific casing.
- **Accented letters in title case** are handled as letters, so `élan vital café` becomes `Élan Vital Café`. Digits are not words: `3rd` stays `3rd`.
- **Scripts without case.** Chinese and Tamil have no upper or lower case and pass through unchanged. In camelCase and similar modes they are treated as ordinary word characters.

> **Tip:** Title case here is mechanical. House styles (AP, Chicago) keep small words such as `of` and `the` lower case; edit those by hand.

## Common mistakes

- Using sentence case on text with lower-case names, or on all-capitals text that contains acronyms, and not re-checking it.
- Expecting `snake_case` to remove punctuation or produce a valid variable name.
- Assuming alternating case alternates letters only; spaces count towards the pattern.
- Converting `ß` or `İ` and being surprised that the character count changes.

## Related tools

[Text to slug](https://toolsg.com/en/text-to-slug) lowercases, strips accents and removes punctuation for URLs. [Word counter](https://toolsg.com/en/word-counter) counts words and characters after you convert. [Text sorter](https://toolsg.com/en/text-sorter) and [Remove line breaks](https://toolsg.com/en/remove-line-breaks) tidy the text before conversion.

## Frequently asked questions

**Is my text sent to a server?**

No. Everything runs in your browser using JavaScript. Nothing you type or paste is uploaded, logged or stored anywhere.

**Is there a length limit?**

There is no fixed limit — the practical ceiling is your browser's memory. Documents of tens of thousands of words are handled comfortably.

**Does it handle non-English text?**

Yes for scripts that have upper and lower case, including accented Latin, Greek and Cyrillic. Chinese, Tamil and other scripts without case are left unchanged, and emoji pass through untouched. The programming cases (camelCase, snake_case and so on) split words at spaces, hyphens, underscores, dots, slashes and changes of case, so they can only split run-together words written in Latin, Greek or Cyrillic letters.

**Does it change my original text?**

No. Your input stays exactly as you typed it; the result is produced separately so you can adjust the options and compare.


## Sources

- [Unicode — SpecialCasing.txt](https://www.unicode.org/Public/UCD/latest/ucd/SpecialCasing.txt) — Unconditional full case mappings such as ß to SS.
- [MDN — String.prototype.toUpperCase()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase)
- [MDN — Word boundary assertion (\b)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Regular_expressions/Word_boundary_assertion)
