Online Case Converter
Convert text between 8 different case styles: UPPERCASE, lowercase, Title Case, Sentence case, camelCase, snake_case, kebab-case, and AlTeRnAtInG. All processing happens locally in your browser.
Result
What is Case Conversion?
Case conversion is the process of changing letters between uppercase and lowercase formats. Different scenarios require different case styles: programming naming conventions (camelCase, snake_case), article titles (Title Case), and everyday text processing (UPPERCASE/lowercase).
This tool provides 8 common case conversion modes to meet the needs of writing, programming, data processing, and more. All operations happen locally in your browser, keeping your text data safe and private.
8 Conversion Modes Explained
- UPPERCASE — Converts all letters to uppercase. Useful for headings, emphasis, or warning text.
- lowercase — Converts all letters to lowercase. Useful for normalizing text format.
- Title Case — Capitalizes the first letter of each word. Ideal for titles, headings, and book names.
- Sentence case — Capitalizes the first letter of each sentence. Standard for article body text.
- camelCase — First word lowercase, subsequent words capitalized. Common in JavaScript variable names.
- snake_case — All lowercase with underscores between words. Popular in Python variable names.
- kebab-case — All lowercase with hyphens between words. Used in CSS classes and URLs.
- AlTeRnAtInG — Alternating uppercase and lowercase letters (odd positions uppercase). For creative text effects.
What case conversion actually changes
Case conversion is not simply "making letters bigger or smaller." Inside a computer, every Latin letter is represented by a Unicode code point, and the Unicode standard defines, for a large set of characters, two correspondences: an "uppercase mapping" and a "lowercase mapping." Converting case means, in essence, walking through the source string and replacing each code point with its counterpart from the mapping table. For example, the lowercase a (U+0061) maps to the uppercase A (U+0041), and the reverse is also true. The part that breaks quietly is that this mapping is not a universal one-to-one flip: in some languages the upper and lower forms of a letter are not symmetric, which is exactly why so many conversions look right but are wrong.
In daily work, case conversion shows up in four distinct situations. The first is writing and typesetting, such as formatting an article title as Title Case or normalizing body text to Sentence case. The second is programming identifiers, where different languages conventionally use styles like camelCase, snake_case, and kebab-case for variables, functions, classes, and files. The third is data cleaning, where user-entered values like "Apple," "APPLE," and "apple" need to be normalized to a single form so they are not treated as three different values. The fourth is brand and trademark conventions, where many logos and product names demand exact casing (think iPhone, macOS, eBay). Understanding what is actually being transformed is what tells you whether a result can be trusted.
Unicode case mapping: more than a simple flip
Unicode defines case mapping at several levels. The most common is the "simple case mapping," where one code point has exactly one upper or lower counterpart; the vast majority of English letters fall into this category. Beyond that, there is the "full case mapping," which takes context and locale into account for more careful handling. The classic counterexample is the German ß, which has no single uppercase character and expands to "SS" when uppercased (so "straße" becomes "STRASSE"). Greek letters can also change case differently depending on whether they sit at the start of a word. Even more locale-dependent are languages where the i/I relationship is inverted, as explained in the FAQ below.
This tool uses a locale-insensitive, general mapping — in other words, the English rule set — which covers the overwhelming majority of English and Latin-script conversion needs. Precisely because it ignores locale, you must be aware that it can produce incorrect output for Turkish, Azerbaijani, and similar texts, and you should switch to the appropriate language rule or manually verify the result when such text is involved.
Eight conversion modes compared
The table below applies every mode supported by this tool to the same input, "hello world," so you can compare them side by side. Note that, except for uppercase and lowercase, every other mode depends on detecting word boundaries — inputs with spaces or hyphens behave the way you expect, while continuous strings do not.
| Mode | Result for "hello world" | Typical use |
|---|---|---|
| UPPERCASE | HELLO WORLD | Emphasis, warnings, constant macros |
| lowercase | hello world | Normalization, case-insensitive comparison |
| Title Case | Hello World | Article titles, book names, headings |
| Sentence case | Hello world | Body paragraphs, sentence-level text |
| camelCase | helloWorld | JavaScript variables and functions |
| PascalCase | HelloWorld | Class, component, and type names |
| snake_case | hello_world | Python variables, database fields |
| kebab-case | hello-world | CSS classes, URL slugs |
How to read it: the table's real value is separating two kinds of operations. Uppercase and lowercase only flip letter case and never touch spaces; camelCase and PascalCase remove spaces and capitalize word initials; snake_case and kebab-case replace spaces with an underscore or a hyphen. If your goal is a code identifier you can paste directly, pick one of the last four; if you are only typesetting, the first four are enough.
Worked examples: turning "hello world" into eight forms
Starting from the input string hello world, here are the actual outputs of each mode in this tool, which you can cross-check against the table above:
Example 1: input hello world. UPPERCASE -> HELLO WORLD; lowercase -> hello world; Title Case -> Hello World; Sentence case -> Hello world; camelCase -> helloWorld; PascalCase -> HelloWorld; snake_case -> hello_world; kebab-case -> hello-world.
Example 2 (word splitting depends on spaces): change the input to the spaceless helloworld and convert to camelCase, and the result is helloworld — the tool cannot find a word boundary, so the whole string is treated as one word. This shows that modes needing tokenization (camelCase, snake_case, Title Case) work best when the input keeps its spaces or existing separators; a continuous string should be cleaned or manually split first, or the result will not match expectations.
Example 3 (longer phrase): input the quick brown fox, camelCase -> theQuickBrownFox, snake_case -> the_quick_brown_fox, kebab-case -> the-quick-brown-fox. The more words, the more visible the difference between the four separator styles becomes, yet the core rule — capitalize the first letter of every word — stays constant.
Case pitfalls in Turkish and similar languages
In Turkish and Azerbaijani the case rules differ from English: the uppercase of i is not I but the dotted İ (U+0130), and the lowercase of I is not i but the dotless ı (U+0131). Under those locales, uppercasing "i" yields "İ" and lowercasing "I" yields "ı," the exact opposite of English i↔I. This tool defaults to a locale-insensitive general mapping (the English rule), so converting Turkish text directly can be wrong: for instance, lowercasing the Turkish city "İstanbul" under English rules gives "istanbul," dropping the dot that should be preserved. When handling such text, apply the language-specific case rules explicitly, or manually verify every dotted and dotless i after conversion.
How Title Case handles abbreviations and hyphens
Title Case looks like a trivial "capitalize the first letter of each word," but it runs into two real problems. First, abbreviations and proper nouns: words like "NASA," "iPhone," and "macOS" that already mix case get mangled into "Nasa," "Iphone," and "Macos," which is actually wrong. Second, hyphens and apostrophes: for "well-known," "state-of-the-art," and "don't," a good implementation also capitalizes the letter after the hyphen or apostrophe (giving "Well-Known," "Don't"), while a naive one might only capitalize the first word. This tool splits on word boundaries, so letters after hyphens and apostrophes are also uppercased; whether an abbreviation should keep its original casing is something the tool cannot know, so manual review after conversion is recommended.
The difference between camelCase and PascalCase
Both remove spaces and capitalize the first letter of each word; the only difference is the very first word. In camelCase the first word is all lowercase, so "hello world" becomes "helloWorld"; in PascalCase the first word is also capitalized, becoming "HelloWorld." That distinction carries meaning in programming: most languages conventionally use PascalCase for types, classes, and components (such as React components in JavaScript, class names in C#, interfaces in Java) and camelCase for variables, functions, and methods. Mixing them up rarely causes a runtime error, but it violates team conventions and hurts readability. This tool offers the two modes separately precisely because they are not interchangeable in naming contexts.
Frequently asked questions
What are the case conversion pitfalls in Turkish and similar languages? In Turkish and Azerbaijani, the uppercase of i is the dotted İ (U+0130) and the lowercase of I is the dotless ı (U+0131), unlike the English i↔I. This tool defaults to a locale-insensitive general mapping (English rules), so converting Turkish text may give wrong results; you should manually verify dotted and dotless i after conversion.
How does Title Case handle abbreviations and hyphens? This tool splits on word boundaries, so letters after hyphens (well-known) and apostrophes (don't) are also capitalized, yielding Well-Known and Don't. But proper nouns like NASA and iPhone that already mix case will be turned into Nasa and Iphone, so keep the original spelling by reviewing the output manually.
What is the difference between camelCase and PascalCase? Both remove spaces and capitalize each word's first letter; the difference is the first word. camelCase keeps the first word lowercase (helloWorld) while PascalCase capitalizes it (HelloWorld). In programming, PascalCase is used for classes, types, and components, whereas camelCase is used for variables and functions, and the two are not interchangeable.