Case Converter

The Case Converter transforms text between every common case style used in writing, programming, and design: UPPERCASE, lowercase, Title Case, Sentence case, camelCase, PascalCase, snake_case, kebab-case, CONSTANT_CASE (SCREAMING_SNAKE_CASE), dot.case, path/case, aLtErNaTiNg case, and iNvErSe case. Paste text in any format and instantly see every variant side-by-side. Essential for developers normalizing variable names, content writers formatting headings, data analysts cleaning up spreadsheet columns, or anyone who needs to switch between naming conventions.

Different programming languages and style guides use different case conventions: JavaScript and Java prefer camelCase for variables and PascalCase for classes; Python and Ruby prefer snake_case for variables and functions; CSS and URLs prefer kebab-case; environment variables and constants use CONSTANT_CASE. Manually converting between these is tedious and error-prone. This tool handles the conversion automatically, including smart word-boundary detection for compound identifiers. Runs entirely in your browser — text stays private.

Each case style has specific rules for word separators, capitalization, and spacing:

UPPERCASE — All characters uppercase.
- Example: HELLO WORLD
- Use: emphasis in text, legal documents, SQL keywords

lowercase — All characters lowercase.
- Example: hello world
- Use: most text, URLs, HTML attributes

Title Case — First letter of each word uppercase (except articles, prepositions for strict Title Case).
- Example: The Quick Brown Fox
- Use: book/movie titles, headings, proper names

Sentence case — First letter of first word uppercase, rest lowercase (except proper nouns).
- Example: The quick brown fox
- Use: normal prose, body text

camelCase — First word lowercase, subsequent words capitalized, no separators.
- Example: helloWorldExample
- Use: JavaScript/Java variables and methods, Swift properties

PascalCase (UpperCamelCase) — Every word capitalized, no separators.
- Example: HelloWorldExample
- Use: classes in C#, Java, JavaScript; types in TypeScript; components in React/Vue

snake_case — All lowercase, words separated by underscores.
- Example: hello_world_example
- Use: Python/Ruby variables and functions, SQL column names, Unix filenames

CONSTANT_CASE (SCREAMING_SNAKE_CASE) — All uppercase, words separated by underscores.
- Example: HELLO_WORLD_EXAMPLE
- Use: constants, environment variables, C preprocessor macros

kebab-case — All lowercase, words separated by hyphens.
- Example: hello-world-example
- Use: CSS class names, URLs, HTML attributes, Hugo/Jekyll post slugs

dot.case — All lowercase, words separated by dots.
- Example: hello.world.example
- Use: nested config keys (Java properties), some APIs

path/case — Lowercase, words separated by slashes.
- Example: hello/world/example
- Use: file paths, URL routes

aLtErNaTiNg CaSe — Alternating upper and lower letters.
- Example: HeLlO wOrLd
- Use: meme text, playful emphasis

iNvErSe cAsE — Swap case of every character.
- Example: hELLO wORLD
- Use: reveal hidden text, mockery

Word boundary detection:

Converting between cases requires identifying word boundaries. The tool handles:

- Space-separated: hello world → splits on space
- camelCase/PascalCase: helloWorld → splits on case change
- snake_case: hello_world → splits on underscore
- kebab-case: hello-world → splits on hyphen
- Mixed: XMLParser → handles acronym-word boundaries (xml_parser or xmlParser)

Edge cases:

- Acronyms: XMLParser — typically keeps acronym as one unit in snake_case (xml_parser). Some conventions use XML_parser or x_m_l_parser.
- Numbers: hello2world — numbers are word characters; may or may not create boundaries depending on config.
- Single characters: a to camelCase is still a.
- Empty strings: Returns empty string.
- Non-ASCII characters: Accented letters, Unicode — some cases only meaningful for ASCII alphabet.

camelCase vs snake_case vs kebab-case: Different language communities prefer different conventions. JavaScript/Java use camelCase; Python/Ruby use snake_case; CSS/URLs use kebab-case. These are conventions, not rules — mixing within a project is discouraged but possible.

Title Case vs Sentence case: Title Case capitalizes each word (like book titles); Sentence case capitalizes only the first word and proper nouns (like normal writing). Style guides vary: AP prefers sentence case for headlines; Chicago uses Title Case.

ALL CAPS vs lowercase: All caps is slower to read and can come across as shouting. Use sparingly for emphasis. Lowercase is neutral and matches body text expectations.

camelCase vs PascalCase: camelCase starts lowercase; PascalCase (UpperCamelCase) starts uppercase. Used for different purposes: camelCase for variables/functions, PascalCase for classes/types/components.

snake_case vs CONSTANT_CASE: snake_case is lowercase with underscores for variables/functions. CONSTANT_CASE is uppercase with underscores for constants/environment variables. Same underscore convention, different visual weight.

kebab-case vs snake_case: Both use separators. kebab-case uses hyphens, better for URLs and HTML (which don't like underscores). snake_case uses underscores, better for programming (many languages don't allow hyphens in identifiers).