Case Converter · Utilities

One phrase, every case style.

Type or paste any identifier and read it back as camelCase, snake_case, kebab-case and eight more — each row copyable, Unicode-aware, and computed entirely in your browser. Free, no signup, and your text never leaves your device.

Runs in your browser — nothing you paste leaves this page. How we prove that

Runs in your browser 11 case styles No signup Updated Jul 28, 2026

Examples

Text to convert

Word boundaries are detected from spaces, hyphens, underscores and camelCase humps — getHTTPResponse splits into get / http / response.

Results update as you type — press Enter to run now.

Results

Type or paste any identifier — or tap an example — to see it in camelCase, snake_case, kebab-case and more, each with a Copy button.

Conversion runs entirely in your browser — nothing is uploaded.

The Gap

The right words, the wrong shape.

Renaming an identifier is rarely a one-off. The database wants snake_case, the JSON API wants camelCase, the environment variable wants SCREAMING_SNAKE_CASE and the URL slug wants kebab-case — retyping the same three words in five shapes is exactly where a typo slips in.

This free case converter reads your text once, detects word boundaries even inside camelCase humps and acronyms, and emits every style at once so you can copy the one you need. It is Unicode-aware, so accented and non-Latin identifiers split correctly — and it runs entirely in the browser, with nothing to install and no data leaving your device.

Don’t ask an AI to reshape it either: a language model is predicting characters, not running a tokenizer, and it will quietly drop or mis-case a word in a long identifier. This tool applies explicit boundary rules every time, so the same input always produces the same rows.

Need a URL slug instead? The Slugify tool handles diacritics, separators and length limits.

The Pipeline

How it works.

Four deterministic steps run on every keystroke — all inside your browser tab, with the same tokenizer applied to every case style.

Split into words.

Your text is tokenized on spaces, symbols and camelCase humps — getHTTPResponse becomes get / http / response.
Normalize the tokens.

Every word is lowercased and acronyms are folded in, so the same phrase always yields the same word list.
Recombine per style.

Words are joined and cased for each convention — a leading-lower camelCase, underscore snake_case, hyphen kebab-case, and so on.
Copy the one you need.

Every style renders as a labeled row with its own Copy button — or Copy all to grab the full set at once.

Case Reference

Every style, side by side.

One input, eleven conventions. The word boundaries are detected once; only the joiner and capitalization change between rows.

The eleven cases

From one phrase — userProfileID — every case style the converter emits.

case-styles

input    userProfileID   ("user profile ID")

camelCase             userProfileId
PascalCase            UserProfileId
snake_case            user_profile_id
SCREAMING_SNAKE_CASE  USER_PROFILE_ID
CONSTANT_CASE         USER_PROFILE_ID
kebab-case            user-profile-id
Train-Case            User-Profile-Id
Title Case            User Profile Id
sentence case         User profile id
dot.case              user.profile.id
path/case             user/profile/id

How boundaries split

Separators, camelCase humps, acronym runs and letter/number transitions all become word boundaries.

tokenizer

getHTTPResponse   ->  get / http / response
user_profile-id   ->  user / profile / id
XMLHttpRequest    ->  xml / http / request
v2Release         ->  v / 2 / release
Release2          ->  release / 2

Next Step

Turning a title into a URL? Slugify it.

kebab-case is close, but a URL slug also needs diacritics folded, symbols stripped and a length cap. The Slugify tool does exactly that — or browse the rest of the Utilities shelf for more identifier and text helpers, all in your browser.

Open Slugify Browse Utilities

slug.txt

Case Converter Guide   (title)
->  kebab-case            case-converter-guide
->  Slugify               case-converter-guide  (url-safe)

FAQ

Questions, answered.

Tap a question to expand the answer.

What case styles does the converter support?

Eleven at once: camelCase, PascalCase, snake_case, SCREAMING_SNAKE_CASE, CONSTANT_CASE, kebab-case, Train-Case, Title Case, sentence case, dot.case and path/case. Type once and every style appears as a copyable row — grab whichever your language, config file or URL needs.

How are word boundaries detected?

The tokenizer is Unicode-aware. It splits on spaces, hyphens, underscores, dots, slashes and other symbols, and also inside camelCase and PascalCase humps — so userProfileID, user_profile-id and "user profile ID" all resolve to the same three words. Letter-to-number and number-to-letter transitions split too, so v2Release becomes v / 2 / release.

How are acronyms like HTTP or URL handled?

Acronyms are normalized, not preserved as all-caps. getURLFromString tokenizes to get / url / from / string, so its camelCase form is getUrlFromString and its snake_case form is get_url_from_string. This is simpler and round-trip stable: feeding the camelCase output back in yields the same words, which the all-caps alternative cannot guarantee.

What is the difference between SCREAMING_SNAKE_CASE and CONSTANT_CASE?

Nothing, in practice — both are uppercase words joined by underscores (USER_PROFILE_ID). They are listed as two rows because different communities use different names: many style guides say "SCREAMING_SNAKE_CASE" while others (and some linters) call the same convention "CONSTANT_CASE" for compile-time constants and environment variables.

Does my text ever leave my browser?

No. Conversion runs 100% client-side in your tab — there is no server, no account and no logging. You can safely paste identifiers, column names or private strings; nothing travels over the network.

Does it handle non-ASCII text and Unicode?

Yes. Boundary detection uses Unicode letter and number properties, so accented and non-Latin letters stay inside their word — straßeName splits into straße / name, and the accented characters are preserved in the output where the case style keeps letters as-is.

Why not just ask an AI to convert the case?

A language model predicts characters; it does not run a deterministic tokenizer. For anything longer than a couple of words it can drop, merge or mis-case tokens in ways that are hard to spot. This tool applies the same explicit boundary rules every time, so the output is reproducible — the same input always yields the same eleven rows.

Can I share a specific conversion?

Yes. Once you have input, use "Copy link" to copy a URL with your text encoded in a #q= fragment. Opening that link restores the input and re-runs the conversion — handy for pasting an example into a code review or issue.

More free, private DevOps tools.

The Case Converter is one tool in OpsCanopy — a growing canopy of browser-based validators, converters and testers that never touch a server.