Convert Text Case — Upper, Lower & camelCase
Convert text between UPPERCASE, lowercase, Title Case, camelCase, and more in one click.
Your text stays on your device
Nothing to delete afterwards
Safe for name and contact lists
Works in every modern browser
How it works
- 1
Paste your text
A sentence, a heading, a list of names, or an identifier you want reshaped.
- 2
Pick the target case
Every form is shown at once, so you can see which one actually reads well.
- 3
Copy the one you want
Take it into a document, a headline, a variable name, or a slug.
Why use this tool
Prose and code conventions
Sentence and title case for writing, plus camelCase, snake_case, and kebab-case for identifiers.
Locale-aware conversion
Turkish dotted and dotless i are handled correctly, which a naive converter gets wrong every time.
German ß handled properly
Uppercasing expands it to SS or uses the capital ẞ — both are defensible, and you choose.
Acronyms kept readable
Converting `parseHTTPResponse` produces a sensible snake_case name rather than one letter per underscore.
Nothing is uploaded
The text is transformed in your browser — draft copy and name lists never reach a server.
Free, no account
No signup, no watermark, no cap on how much you convert.
Case is a property of a language, not of a character
This is the fact that makes case conversion harder than it appears, and the clearest demonstration is Turkish. English has one `i`, and its uppercase is `I`. Turkish has two: a dotted `i` whose capital is `İ`, and a dotless `ı` whose capital is `I`. So the single operation "make this uppercase" gives different answers depending on the language of the text — and a converter that assumes English silently rewrites Turkish words into different words. This is not a curiosity. The so-called Turkish i problem has broken real production systems, because code that lowercases a configuration key or a username without specifying a locale behaves differently on a machine set to Turkish, turning `INFO` into `ınfo` and failing a comparison that worked everywhere else. If your text is Turkish, the locale is not a detail.
Some characters change length when the case changes
The comfortable assumption is that uppercasing swaps each letter for another letter. It mostly does, and the exceptions are worth knowing because they break code that assumes a fixed length. German ß is the famous one: its traditional uppercase is `SS`, so `Straße` becomes `STRASSE` and gains a character. A capital ẞ was later added to Unicode and is now accepted in official German orthography, which means two defensible answers exist and tools disagree. Greek has a subtler case: lowercase sigma is written `σ` in the middle of a word and `ς` at the end, so lowercasing `ΟΔΟΣ` correctly requires knowing that the sigma is final. Ligatures behave the same way. None of this matters for an English headline and all of it matters if you are validating length or comparing strings after a conversion.
Title case is a style decision, not a transformation
Upper and lower case are mechanical. Title case is not, and no algorithm produces it correctly without knowing which style guide you are following. The English convention capitalises the first and last words and everything in between except short articles, conjunctions, and prepositions — but guides disagree about the cutoff. Chicago lowercases prepositions of any length; AP capitalises those of four letters or more, so "Through" is capitalised in one and not the other. Beyond that, the whole convention is English-specific. Spanish, French, and Portuguese capitalise only the first word and proper nouns, so applying English title case to a Spanish heading produces something that looks visibly wrong to a native reader. Treat the automatic result as a first pass to correct, not as an answer.
Converting between code conventions is a word-boundary problem
camelCase, PascalCase, snake_case, kebab-case, and SCREAMING_SNAKE_CASE all encode the same thing — where one word ends and the next begins — using different punctuation. Converting between them therefore means finding those boundaries, and that is where it gets ambiguous. Underscores and hyphens are explicit and easy. A camel hump is usually a boundary, except when it is an acronym: `parseHTTPResponse` has three words, but a naive rule that starts a new word at every capital produces `parse_h_t_t_p_response`. The workable rule treats a run of capitals as one word, breaking before the last capital if a lowercase letter follows, which turns `parseHTTPResponse` into `parse_http_response` and `HTTPServer` into `http_server`. Digits are the other edge: whether `utf8Encode` splits before the 8 is a judgement call, so check identifiers containing numbers.
Uppercasing is not reversible, and comparison needs more than lowercase
Once text is uppercased, the information about which letters were originally capitals is gone — `iOS` and `IOS` and `ios` all become `IOS`, and nothing can distinguish them afterwards. This is obvious stated plainly and routinely forgotten in practice, which is why destructive case changes should happen on a copy. The related trap is case-insensitive comparison. Lowercasing both sides is the usual approach and it is not quite correct: proper case folding handles ß against SS, the Greek final sigma, and the Turkish i, where naive lowercasing does not. For a search box the difference rarely matters. For matching usernames, deduplicating records, or checking uniqueness, it is exactly the kind of gap that lets two different values look identical, or two identical ones look different.
Why converting locally matters for this kind of text
Consider what people put through a case converter. It is a headline being drafted before publication, a list of customer or employee names being tidied for import, a column of email addresses, a product catalogue, a set of identifiers pulled from a database schema. None of it looks secret, which is precisely why it gets pasted without a second thought — and a list of five hundred real names is personal data whether or not it feels like it. A hosted converter receives every line. This tool transforms the text in the page and sends nothing, which you can confirm in the Network tab of your developer tools. For a task this casual and this often applied to real records, the default is worth having right.
Common mistakes to avoid
- Lowercasing text without specifying a locale. On a Turkish system `I` becomes `ı` rather than `i`, which silently breaks comparisons of configuration keys and usernames that worked everywhere else.
- Assuming case conversion preserves length. German ß uppercases to SS and gains a character, so any validation counting characters after a conversion needs to run on the converted string.
- Applying English title case to other languages. Spanish, French, and Portuguese capitalise only the first word and proper nouns, so an English-style heading reads as visibly wrong to a native speaker.
- Splitting a new word at every capital letter. `parseHTTPResponse` becomes `parse_h_t_t_p_response`; treat a run of capitals as one word and break before the last one only if a lowercase letter follows.
- Using naive lowercasing for case-insensitive matching. Proper case folding handles ß, the Greek final sigma, and the Turkish i — which matters when you are deduplicating records or checking uniqueness.
How it compares
| Aspect | This tool | Online converters | An editor command |
|---|---|---|---|
| Content sent to a server | Never | Usually yes | No |
| Turkish i handled correctly | Yes | Rarely | Varies |
| Code naming conventions | Yes | Sometimes | Usually not |
| All forms shown at once | Yes | Rarely | One per command |
| Account or signup | Not needed | Often required | Not needed |
| Price | Free | Free / paid tiers | Free / paid |
Features
Seven case forms
UPPER, lower, Sentence, Title, camelCase, snake_case, and kebab-case from one input.
Turkish i rules
The dotted and dotless i convert as Turkish requires rather than as English assumes.
Word-boundary detection
Spaces, hyphens, underscores, and camel humps are all recognised as boundaries.
Full Unicode coverage
Arabic, Greek, Cyrillic, and accented Latin all pass through with correct handling.
Handles long input
Whole documents convert without an upload or a size cap.
Nothing is lost in place
The original stays visible alongside the result, so you can compare before replacing.
Nothing to install
No editor macro, no runtime, no dependencies — it runs on the web page.
Arabic and RTL ready
Full interface in eight languages, including right-to-left Arabic.
Secure by default
Served over HTTPS, with no content tracking and no third-party upload.
Who uses it
Writers and editors
Fixing a headline that arrived in all caps without retyping it word by word.
Developers
Converting identifiers between naming conventions when moving code between languages.
Data analysts
Normalising a column of names or codes before matching it against another dataset.
Content editors
Turning a title into a URL slug without introducing stray hyphens or lost accents.
Frequently Asked Questions
No. Everything runs locally in your browser — your text is never uploaded, stored, or shared.
Yes — completely free, with no account and no limits.