Case Converter — UPPERCASE, lowercase, camelCase & More

What Is a Case Converter?

// The tokenizer that powers every programming-case conversion
function tokenize(input) {
  return input
    .replace(/([a-z0-9])([A-Z])/g, '$1 $2')      // lower→upper: parseHTML → parse HTML
    .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2')   // acronym boundary: XMLHttp → XML Http
    .replace(/([A-Za-z])(\d)/g, '$1 $2')          // letter→digit: file2 → file 2
    .replace(/(\d)([A-Za-z])/g, '$1 $2')          // digit→letter: 2x → 2 x
    .replace(/[\s\-_./\\]+/g, ' ')                // collapse separators
    .split(' ').filter(Boolean);
}

// Then each case is a one-liner over the tokens
const camelCase  = (s) => tokenize(s).map((t, i) => i === 0 ? t.toLowerCase() : cap(t)).join('');
const snakeCase  = (s) => tokenize(s).map(t => t.toLowerCase()).join('_');
const kebabCase  = (s) => tokenize(s).map(t => t.toLowerCase()).join('-');
const PascalCase = (s) => tokenize(s).map(cap).join('');

function cap(t) {
  return t.charAt(0).toUpperCase() + t.slice(1).toLowerCase();
}

Key Features

Case Converter Alternatives Compared

Case Conversion Examples

URGENT: PLEASE REVIEW THE Q4 BUDGET PROPOSAL BEFORE FRIDAY

user_profile_image_url

XMLHttpRequest

10 Tips for Faster JavaScript: A Complete Guide

accessControlAllowOrigin

max retries per request

this is fine, everything is going great

How to Use the Case Converter

1. 1

   Paste or type your text

   Click into the editor and type, or paste any text — a sentence, a paragraph, an identifier, a heading. Every case output updates instantly. Click Sample to load a representative phrase if you just want to see how the cases differ.

2. 2

   Scan the grid

   The seven text cases (UPPERCASE, lowercase, Title, Sentence, iNVERSE, aLtErNaTiNg, RaNdOm) are in the top section. The eight programming cases (camelCase, PascalCase, snake_case, kebab-case, CONSTANT_CASE, dot.case, path/case, Header-Case) are in the bottom section. Each card shows its case label, a one-line description, and the converted output.

3. 3

   Click Copy on the case you want

   Each output card has its own small Copy button. Click once — the case lands in your clipboard, the button flashes "Copied!", and you're ready to paste somewhere else. No need to highlight the output text first.

4. 4

   Re-shuffle the random case if needed

   If you want a different RaNdOm CaSe variant for the same text, click Re-shuffle in the action bar. Only the Random Case output changes; the input text and all other outputs stay the same.

5. 5

   Clear when done

   Click Clear to empty the editor and reset every output. Sample reloads the demo text. All actions are instant and never sent to a server.

Common Case-Conversion Mistakes

Input: "the quick brown fox jumps over the lazy dog"
snake_case output: the_quick_brown_fox_jumps_over_the_lazy_dog
Result: a 50-character identifier no one wants.

Input: "quickBrownFox"
snake_case output: quick_brown_fox
Result: a clean three-token identifier.

Input: "a tale of two cities"
This tool's Title Case: A Tale Of Two Cities
Expected (AP style): A Tale of Two Cities

Use this tool for general capitalization.
Use an AP-style headline tool for editorial titles.
Different tools, different conventions.

Input: XMLHttpRequest
PascalCase output: XmlHttpRequest
Expected (acronym-preserved): XMLHttpRequest

Accept the title-cased acronym, OR
Manually preserve the acronym after conversion, OR
Use a tokenizer that respects acronym hints.

Input: https://example.com/api/users
snake_case output: https_example_com_api_users
Result: not a URL anymore.

Input: https://example.com/api/users
Leave URLs alone — they're already in the right format.
For slug extraction, parse the URL path manually.

Goal: "set the user.profile.image variable"
Using dot.case output as a variable name: `user.profile.image`
In most languages this is property access, not an identifier.

For a single variable: userProfileImage (camelCase).
For a namespaced key: user.profile.image (dot.case is correct).
Match the case to the target syntax.

Input: "e.g. this is an example. Read more."
Sentence case output: "E.g. This is an example. Read more."
The `g.` was mistakenly treated as a sentence terminator.

Run sentence case first, then hand-fix the few abbreviation edge cases.
Or re-phrase to avoid sentence-internal periods.
(NLP-grade sentence detection is a separate tool category.)

Who Uses This Tool

Developers Renaming Identifiers Across Languages

Migrating a JS variable to a Python snake_case name, or a CSS class to a React PascalCase component, or an environment variable to a config constant. Paste the source name once, copy the right output — no manual letter-by-letter conversion.

Backend Devs Translating Header Names

HTTP headers like Content-Type, Access-Control-Allow-Origin, X-Forwarded-For have specific Header-Case spellings. Paste a camelCase JS property name, copy the canonical header form — works for fetch() options, server middleware, and proxy configs.

Writers Removing ALL-CAPS Email Tone

Forwarded all-caps emails and chat messages read as shouting. Paste them into Sentence case to defuse the tone, or Title Case to keep a polished-headline feel. Whitespace and punctuation survive intact.

Marketers Drafting Headlines

Title Case for headlines, Sentence case for body copy and captions — the convention most modern style guides (AP, Google, Apple) recommend. See both at once to compare which fits the placement.

SEO Specialists Generating URL Slugs

kebab-case is the URL-slug convention every CMS expects. Paste a page title with punctuation and capitalization, copy the kebab-case output — ready to drop into a WordPress, Ghost, or Hugo slug field. Tokenizer strips punctuation cleanly.

DBAs Naming Columns and Tables

snake_case for column and table names is the universal convention across PostgreSQL, MySQL, SQLite, and most ORMs. Paste a human-readable label or a camelCase API field name, copy the snake_case version.

Frontend Devs Authoring CSS Classes

kebab-case for class names is the CSS spec convention (BEM, Tailwind utilities, and most design systems). Paste a JS component name in camelCase, copy the kebab-case version for the matching CSS module.

Meme-Makers and Sarcasm Enthusiasts

aLtErNaTiNg cAsE and RaNdOm CaSe are the spongebob-meme formats used to mock or quote sarcastically. Re-shuffle re-rolls the random variant without changing the input — generate a few until one feels right.

Tokenization & Conversion Rules

Tokenization Rules

Tokens are extracted by inserting a space at four boundaries: lower-to-upper (parseHTML → parse HTML), upper-to-upper-to-lower (XMLHttp → XML Http), letter-to-digit (file2 → file 2), and digit-to-letter (2x → 2 x). Then common separators (whitespace, hyphen, underscore, dot, slash, backslash) are collapsed to single spaces. The resulting tokens are split, trimmed, and empties dropped. This matches the lodash and change-case package conventions.

Programming-Case Outputs Strip Punctuation

camelCase, PascalCase, snake_case, kebab-case, CONSTANT_CASE, dot.case, path/case, and Header-Case all produce clean identifiers — punctuation in the input (commas, periods, parentheses) is dropped because it can't appear in most language identifiers. If you need punctuation preserved, use one of the text-case outputs (UPPERCASE, lowercase, Title, Sentence, iNVERSE, aLtErNaTiNg, RaNdOm).

Text-Case Outputs Preserve Everything

UPPERCASE, lowercase, Title Case, Sentence case, iNVERSE cASE, aLtErNaTiNg cAsE, and RaNdOm CaSe all preserve whitespace, line breaks, and punctuation. Paste a multi-paragraph document and the structure survives — only letter casing changes. These transforms operate character-by-character without tokenization.

Title Case (Naive Variant)

Title Case in this tool capitalizes the first letter of every whitespace-separated word and lowercases the rest. APA, Chicago, and AP style guides recommend lowercasing short articles and prepositions (a, an, the, of, in, for); those variants are different enough to warrant a dedicated tool. Use this Title Case for general capitalization; use a headline-specific tool for AP-style headlines.

Sentence Case Boundary Detection

Sentence case lowercases everything, then capitalizes the first letter of the input and the first letter after any sentence terminator (. ! ? 。 ！ ？) followed by whitespace. The detector doesn't try to disambiguate abbreviations like Mr. or U.S.A. — false positives there are noisier than the rare missed case.

Alternating Case Uses a Global Toggle

aLtErNaTiNg cAsE flips between lower and upper for each letter, with a global toggle that carries across word boundaries. Non-letter characters don't advance the toggle. This matches the convention used by convertcase.net and other meme generators — predictable and reproducible for the same input.

Random Case Uses Math.random()

RaNdOm CaSe runs an independent coin-flip per letter using Math.random(). Each Re-shuffle click produces a different result. The random source isn't cryptographically strong; it's fine for casual text but don't use it for password generation (use the dedicated password generator for that).

Unicode and Locale-Aware Case Mappings

Uses `toLocaleLowerCase()` and `toLocaleUpperCase()` so Turkish dotted/dotless İ/ı, German ß (uppercases to SS in standard handling), and other locale-sensitive case mappings handle correctly. Tokenization uses \p{L} to recognize letters from any script. Programming-case outputs default to ASCII identifier characters for cross-language compatibility.

Best Practices for Choosing a Case

Pick the Case That Matches Your Codebase

The right case for a variable name isn't the prettiest — it's the one your codebase already uses. JavaScript and Java: camelCase for variables and methods, PascalCase for classes. Python, Ruby, Rust: snake_case for everything except class names (which are PascalCase). CSS and URLs: kebab-case. Environment variables and constants: CONSTANT_CASE. Match the local convention; consistency beats theoretical correctness.

Use Sentence Case for UI Microcopy

Google, Apple, and Microsoft's design systems all standardized on Sentence case for button labels, menu items, dialog text, and other UI microcopy over the last decade. Title Case in UI now reads as old-fashioned and slightly shouty. Save Title Case for primary headlines, page titles, and book titles.

Strip Smart Quotes Before Pasting

Pasting from Microsoft Word, Google Docs, or Apple Notes can pull in smart quotes (“”), em-dashes (—), and other typographic characters that look identical to ASCII but encode differently. The case transforms handle them correctly, but if you're converting to a programming-case identifier, manually replace them with ASCII equivalents first to avoid surprises in your code editor.

Convert One Identifier at a Time for Programming Cases

camelCase, snake_case, kebab-case, etc. produce a single identifier from the entire input. If you paste a sentence into snake_case, you get one long identifier — technically correct but rarely what you want. For identifier conversion, paste one word or compound at a time. For paragraph-length text, use the text-case transforms.

Verify Acronym Round-Trips Before Refactoring

XMLHttpRequest → xml_http_request → XmlHttpRequest is the standard round-trip; the acronym becomes title-cased on the way back. If your codebase preserves the original acronym capitalization (XmlHttpRequest stays as XMLHttpRequest), the round-trip won't match exactly. Spot-check a few conversions before doing a project-wide rename.

Use Header-Case for HTTP/1.1, kebab-case for HTTP/2

HTTP/1.1 is case-insensitive for header names but Header-Case (Content-Type, X-Forwarded-For) is the conventional human-readable spelling everyone uses. HTTP/2 explicitly requires lowercase header names — use kebab-case for those (content-type, x-forwarded-for). When in doubt, kebab-case works in both protocols.

Re-Shuffle Random Case for Variety, Not Security

Random Case is fun for memes but not random in the cryptographic sense — it uses Math.random(), which is fine for visual variety but not for anything where randomness matters (password generation, security tokens, A/B testing). Use the dedicated password generator for cryptographic randomness.

Frequently Asked Questions