Skip to content

Case Converter — UPPER, lower, Title, camelCase Online

Last verified May 2026 — runs in your browser

Case Converter — Uppercase, Lowercase, Title & camelCase Online

Paste any text and pick a style — UPPERCASE for shouting headers, lowercase for normalising input, Title Case for headlines, Sentence case for prose, then four programmer styles for naming things in code (camelCase, PascalCase, snake_case, kebab-case). The four code styles automatically strip diacritics first using NFD Unicode normalisation, so "Café Móvil" becomes a clean `cafeMovil` instead of breaking on "é". The active style is highlighted so you can A/B-compare a few before settling, and a single Copy button puts the result on your clipboard. Useful for naming a new file/branch/database column, normalising user input from a form, generating a JSON key from a human label, or cleaning up a copy-pasted heading before it goes into a CMS.

About this tool

Title Case capitalises the first letter of every whitespace-separated word and lowercases the rest, which is fast and good enough for most headlines (it does NOT do English style-guide "don't capitalise short words" rules — that's a different tool). Sentence case lowercases everything then re-capitalises after `.`, `!`, `?` followed by whitespace, so multi-sentence input gets each sentence's first letter back. The four programmer styles all start by NFD-normalising the input and stripping the resulting combining marks (`U+0300`-`U+036F`), then collapse non-alphanumerics: camelCase capitalises every word boundary character and lowercases the very first; PascalCase is camelCase with the first character also capitalised; snake_case joins lowercased word boundaries with `_`; kebab-case is snake_case with `-` instead of `_`. The snake/kebab paths also split on lowercase-to-uppercase transitions inside the input, so an existing `myCamelCase` correctly becomes `my_camel_case` rather than `mycamelcase`. All transforms are pure JavaScript string operations — no upload, no API. Use cases: naming a new git branch, generating a database column from a label, building a CSS class from a section heading, prepping a slug from a title, or normalising a CSV header row.

  • 8 styles: UPPER, lower, Title, Sentence, camelCase, PascalCase, snake_case, kebab-case
  • Programmer styles auto-strip diacritics via NFD normalisation
  • snake/kebab split on lowercase→uppercase transitions (myFoo → my_foo)
  • Sentence case re-capitalises after . ! ? + whitespace
  • Title Case capitalises every whitespace-separated word
  • One-click switching between styles, active style highlighted
  • Copy result to clipboard with confirmation toast
  • Reactive — output updates instantly when you change style
  • Pure client-side string transforms, no API call
  • Useful for branch names, DB columns, CSS classes, slugs, CSV headers

Free. No signup. Your inputs stay in your browser. Ads via Google AdSense (consent required).

Frequently asked questions

Why does NFD normalization strip diacritics from 'café' but not from emoji or CJK characters?

NFD (Canonical Decomposition, defined in UAX #15 — Whistler ed., revision 57 tied to Unicode 17.0) splits precomposed characters into a base letter plus combining mark — so 'é' (U+00E9) decomposes to 'e' (U+0065) + combining acute accent (U+0301). The combining mark sits in the Combining Diacritical Marks block (U+0300–U+036F), and a regex strip after normalize removes it cleanly. Emoji like 😀 (U+1F600) and CJK ideographs like 漢 (U+6F22) are atomic — they have no canonical decomposition into base + combining mark, so NFD leaves them as a single code point and the diacritic regex doesn't touch them. The four programmer styles (camelCase, PascalCase, snake_case, kebab-case) then strip everything outside ASCII letters and digits, which is when emoji and CJK get dropped — but that's the alphanumeric filter, not the NFD pass.

Why does snake_case turn 'myCamelCase' into 'my_camel_case' rather than 'mycamelcase'?

The snake_case and kebab-case paths split on lowercase-to-uppercase transitions inside the input before joining with the separator. The regex inserts a boundary wherever a lowercase letter or digit is immediately followed by an uppercase letter, so 'myCamelCase' becomes 'my Camel Case' internally, then lowercases to 'my camel case', then joins with '_'. This is the standard convention shared by most snake_case libraries (Ruby's `underscore`, Python's `inflection`, Lodash's `_.snakeCase`) — it preserves the word boundaries an existing camelCase identifier already encodes, rather than collapsing them. The same logic produces 'parse_html_file' from 'parseHTMLFile' — consecutive caps are treated as a single word boundary, and the entire result is lowercased per the snake_case convention.

Does Title Case follow English style-guide rules about short words?

No — this implementation capitalizes the first letter of every whitespace-separated word and lowercases the rest, which is the simple algorithmic Title Case. English style guides (AP, Chicago Manual of Style, APA) all add an additional rule that articles ('a', 'an', 'the'), short conjunctions ('and', 'but', 'or'), and short prepositions ('in', 'on', 'of') stay lowercase unless they're the first or last word — so a strict-AP version of 'A Tale of Two Cities' is 'A Tale of Two Cities', not 'A Tale Of Two Cities'. The simple version is correct for headlines in CMS systems, code identifiers, and most casual use; for editorial copy targeting a specific style guide, post-processing the output to lowercase the function-word list closes that gap.

Why doesn't this counter handle Turkish I/i case folding correctly?

JavaScript's String.prototype.toLowerCase / toUpperCase use the default Unicode case mappings. Under default Unicode, dotted İ (U+0130) lowercases to plain i + combining dot above (U+0069 + U+0307) — the combining mark preserves roundtrip information that the source had a dotted capital — and dotless capital I (U+0049) lowercases to plain Latin i (U+0069). Turkish has a different convention: under the Turkish locale, dotted İ lowercases to plain i (U+0069) and dotless capital I lowercases to Turkish dotless ı (U+0131). To get the Turkish convention, applications call String.prototype.toLocaleLowerCase('tr'), which uses the locale-aware mapping coordinated with ECMA-402's locale resolution. This tool ships the default Unicode mapping because Turkish-specific identifier conventions are rare in global naming use cases; for code or filenames targeting Turkish locales, the locale-aware variant covers the gap. The same caveat applies to Azerbaijani (az), which shares Turkish dotted/dotless I.

How does this tool handle accessibility for screen readers?

The output region for each style is marked aria-live="polite", the W3C WCAG Success Criterion 4.1.3 (Status Messages, introduced in WCAG 2.1, Recommendation 5 June 2018; carried unchanged into WCAG 2.2, Recommendation 5 October 2023) pattern. Polite live regions queue announcements after any speech in progress, so switching styles or editing input announces the result without interrupting the user mid-sentence. Screen readers (NVDA, JAWS, VoiceOver) consume the live region automatically; nothing else is required from the user.

Sources (5)
  • Whistler, K. (Ed.) (2025). UAX #15: Unicode Normalization Forms. Unicode Standard Annex, Revision 57 (Unicode 17.0.0, 30 July 2025).
  • The Unicode Consortium (2024). The Unicode Standard, Version 16.0 — UCD CaseFolding.txt (simple vs full case folding). Unicode Consortium, Mountain View, CA.
  • ECMA International (2025). ECMAScript 2025 Language Specification — String.prototype.toLowerCase / toUpperCase / normalize. ECMA-262, 16th edition, June 2025.
  • ECMA International (2025). ECMAScript 2025 Internationalization API Specification — locale-aware case behavior (Turkish I/ı, dotted/dotless). ECMA-402, 12th edition, June 2025.
  • World Wide Web Consortium (W3C) (2018). Web Content Accessibility Guidelines (WCAG) 2.1 — Success Criterion 4.1.3 Status Messages. W3C Recommendation 5 June 2018; carried unchanged into WCAG 2.2 (Recommendation 5 October 2023).

These are the original publications the formulas in this tool are based on. Locate them by journal name and year on Google Scholar or PubMed.