Loading…
Convert text between camelCase, PascalCase, snake_case, kebab-case, CONSTANT_CASE, Title Case, and more — all at once, with correct acronym handling and multi-line support.
This case converter takes a name written in any convention — camelCase, PascalCase, snake_case, kebab-case, CONSTANT_CASE, dot.case, or plain words — and rewrites it in every other convention at once. It works by first splitting the input into words, then joining those words back together in each target style. That two-step approach is what lets it read `user_profile_id`, `userProfileId`, and `USER-PROFILE-ID` as the same three words, and why it doesn't care how consistent the input was to begin with.
Naming conventions differ because ecosystems standardised at different times and for different reasons. C and its Unix heritage favoured lowercase with underscores, which Python and Ruby inherited and which SQL adopted for column names because most databases fold unquoted identifiers to a single case anyway. Smalltalk popularised camelCase, Java made it the default for variables and methods with PascalCase reserved for types, and JavaScript followed Java's lead. The web layer went its own way: URLs and CSS classes use kebab-case, partly because a hyphen survives case-insensitive systems intact and partly because `_` is hard to see under a link underline. Shell and CI tooling settled on CONSTANT_CASE for environment variables, a convention old enough that it predates most of the languages reading them.
None of this matters until you cross a boundary — and modern work crosses them constantly. A snake_case Postgres column becomes a camelCase field in your API layer, then a kebab-case query parameter, then a CONSTANT_CASE environment variable when it gets promoted to config. Renaming those by hand is where typos come from, especially with acronyms: `parseHTTPResponse` should become `parse_http_response`, not `parse_h_t_t_p_response`. This tool tokenises acronym runs and version-style digits correctly, converts each line of a multi-line paste independently so you can rename a whole column list in one go, and runs entirely in your browser — nothing you type is uploaded or stored.
Both join words without separators; they differ only in the first letter. camelCase starts lowercase (`userProfileId`) and is the convention for variables, function names, and object properties in JavaScript, Java, and Swift. PascalCase — also called UpperCamelCase — capitalises the first word too (`UserProfileId`) and is reserved for things that name a type: classes, interfaces, enums, and React components.
Use snake_case where the text has to be a valid identifier in code: Python and Ruby variables, SQL column names, Rust functions, and most protocol buffer or JSON schema fields. Use kebab-case where the text appears in a context that treats a hyphen as a plain character but forbids or discourages underscores — URLs and slugs, CSS class names, HTML attributes, npm package names, and file names. A hyphen is not a legal character in most identifiers, which is exactly why the two conventions never overlap.
A run of capitals is treated as one word, and the run stops one letter early when the next character is lowercase. So `parseHTTPResponse` splits into `parse` + `HTTP` + `Response`, and `XMLHttpRequest` splits into `XML` + `Http` + `Request`. Cases that keep separators preserve the acronym (`parse_http_response`, `XML_HTTP_REQUEST`), while camelCase and PascalCase normalise it to a single leading capital (`parseHttpResponse`, `XmlHttpRequest`) — which is what most style guides, including Google's and Microsoft's, recommend for readability.
It capitalises every word except short function words — articles, coordinating conjunctions, and short prepositions such as a, an, the, and, but, of, in, on, to, for — which stay lowercase unless they are the first or last word. That follows the common Chicago and AP style convention, so `the lord of the rings` becomes `The Lord of the Rings`. If you want every word capitalised with no exceptions, use PascalCase and add spaces, or edit the result directly.
Yes, and each line is converted on its own rather than being merged into one long identifier. Paste a list of database columns, environment variables, or field names — one per line — and every output keeps the same line structure, including blank lines. That makes it practical for renaming an entire schema or config block in a single step.