A case converter that knows where the words begin.
Paste any string — camelCase, snake_case, kebab-case, sentence — and get every common case style at once. Smart word-boundary detection handles acronyms, digits, and mixed input. Runs entirely in your browser; nothing is uploaded.
Your input never leaves your machine. The tokenizer and every case formatter run in this browser tab — pure JavaScript string manipulation, no libraries, no network calls. We never see what you paste.
Twelve cases at once, with the tokenizer that catches what you mean.
The features people actually use when renaming variables, building APIs, or normalizing data — all twelve cases laid out side by side, smart input parsing, and a copy button on each cell.
camelCase, PascalCase, snake_case, SCREAMING_SNAKE, kebab-case, COBOL-CASE, dot.case, path/case, Title Case, Sentence case, UPPER, lower — all rendered the moment you type. No mode toggle to forget.
Splits on lowercase→uppercase transitions (camelCase), separators (`_`, `-`, `.`, `/`), and whitespace. Mixed input like `parse_HTMLString` tokenizes as `parse / HTML / String` — not `parse / h / t / m / l / String`.
Consecutive uppercase letters are treated as a single acronym token. `parseHTMLString` becomes `Parse HTML String`, not `Parse H T M L String`. Recombines correctly when emitting Pascal or Title case.
Digits become their own boundary. `version2Beta` parses as `version / 2 / Beta`. Useful for normalizing identifiers that mix words and version numbers.
Click any case label to copy its current value. The button flashes to confirm — no clipboard guessing.
Every keystroke triggers a re-tokenize and re-render. No Convert button blocking your flow.
Implementation is ~120 lines of JavaScript. No third-party library, no bundle bloat, no surprises in the network tab.
Use it anonymously, on as many strings as you want. No account, no cookies, no usage counter. Pair with the JSON formatter or JWT decoder for the full back-of-the-envelope dev workflow.
Wherever names have to look right.
Find / replace gets you the same name everywhere — but config keys, env vars, CSS classes, and constants all want different cases. Paste the canonical name, copy the right form for each call site.
Spec files often list resource names in PascalCase or sentence form. Convert each to kebab-case for the URL path, snake_case for query params, and camelCase for response keys.
CSV imports come with whatever the spreadsheet author typed — "First Name", "first_name", "FirstName". Convert every header to your project convention before generating type definitions.
Marketing hands you a section title; you need a CSS class. Paste the title, copy the kebab-case version. Same trick for filenames in design exports.
TypeScript or Go enum members usually want SCREAMING_SNAKE. Paste the human-readable label, grab the constant form. Works equally well for environment variable names.
Need a clean URL slug from a page title? kebab-case is your friend. Lowercase + dashes + ASCII = the canonical web slug.
Case conversion, the plain answers.
A single tokenizer pass: split on `_`, `-`, `.`, `/`, whitespace, then walk the remaining characters and break on lowercase→uppercase transitions and on digit boundaries. Consecutive uppercase letters are kept together as an acronym, except when followed by a lowercase letter — `HTMLParser` becomes `HTML / Parser`, not `HTM / L / Parser`.
Treated as single tokens. `httpRequest` → `http / Request`. `parseURLString` → `parse / URL / String`. When emitting Pascal or Title case, the acronym keeps its all-caps form: `parseURLString` → `ParseURLString`. snake / kebab forms lowercase everything: `parse_url_string` and `parse-url-string`.
Letters from any Unicode script are kept as part of the current token; they do not act as boundaries. `привіт_світ` → `привіт / світ`, then formats normally. Case toggles use `String.prototype.toLowerCase` / `toUpperCase`, which honor the active locale via the JavaScript engine.
Train-Case is just Title Case with hyphens — derivable from the Title Case output by replacing spaces. We picked the twelve cases that show up most often in real codebases (build systems, ORMs, env vars, CSS, URLs). If you want a specific case added, drop us a note via /contact.
No. Every byte runs in this browser tab — the tokenizer is ~120 lines of plain JavaScript. The page makes no network calls related to your input. Open DevTools → Network while you paste, and nothing outbound appears.
Sort of — paste each line into the input and the output reflects whatever the tokenizer makes of the whole blob. For real batch work (a column of names from a CSV, say) the better path is a one-line script: `import { camelCase } from "lodash"; rows.map(camelCase)`. The browser tool is for one-off conversions while you are mid-edit.
Building services where naming actually matters?
Sign up for the free tier and you get $100 in credits, plus VMs, managed databases, object storage, and zero-config autoscaling across four regions.