Convert text case _

What is text case conversion?

Text case conversion takes an input string and emits the same words rendered in a different letter-case convention. The most common targets are camelCase and PascalCase (used for identifiers in most curly-brace languages), snake_case and CONSTANT_CASE (Python, Ruby, Rust, C macros), kebab-case (URLs, CSS class names, HTML attributes, npm package names), dot.case (configuration keys, JavaScript object paths), path/case (filesystem-style identifiers), Title Case and Sentence case (headlines and prose), plus full lower case and UPPER CASE. This converter detects the natural word boundaries in your input — whitespace, hyphens, underscores, dots, slashes, and the lowercase→uppercase transitions that mark helloWorld-style identifiers — and reassembles them with the separator and capitalisation pattern each target case requires.

How does case conversion work?

Your input is processed entirely in your browser using a small vanilla-JavaScript tokeniser and eleven case formatters. The high-level steps are:

1. Your input is read verbatim from the textarea — every byte you pasted is kept in memory locally.
2. A tokeniser splits the input on whitespace, underscores, hyphens, dots, and slashes, then further splits each chunk on lowercase→uppercase boundaries (so helloWorld becomes ["hello", "World"]) and on letter↔digit boundaries (so v2API becomes ["v", "2", "API"]).
3. Empty tokens are filtered out and the surviving tokens are lowercased using String.prototype.toLocaleLowerCase so Unicode letters in Turkish, German, and other locales are preserved correctly.
4. Eleven formatters then assemble the tokens into each target case in turn — camelCase, PascalCase, snake_case, CONSTANT_CASE, kebab-case, dot.case, path/case, Title Case (with a small-words list so and, the, of, etc. stay lowercase except as first or last word), Sentence case, full lower case, and full UPPER CASE.
5. Output is written to one row per case in the result grid; each row has its own copy button that uses the asynchronous Clipboard API with a synchronous document.execCommand('copy') fallback for older browsers.

Why use a case converter?

• Refactor identifiers: rename a JavaScript variable from user_id to userId, a Python function from helloWorld to hello_world, or a Rust constant from maxBuffer to MAX_BUFFER without hand-editing one character at a time.
• Convert configuration keys: flip a JSON config full of camelCase keys to snake_case YAML for a Python service, or to kebab-case for a Helm chart, in a single paste.
• Write headlines: paste a draft headline and read back the Title Case form (with the Chicago Manual of Style small-words exceptions) next to the Sentence case form (AP Stylebook) — choose whichever your publication uses.
• Generate URL slugs: paste a blog post title and copy the kebab-case form straight into your CMS's slug field — the tokeniser handles punctuation and multi-word phrases without leaving stray separators behind.

What are common applications of case conversion?

Switching between letter-case conventions shows up across software engineering, content authoring, and data engineering:

• Code refactoring: rename identifiers across a codebase when a style guide changes (e.g. JavaScript camelCase → Python snake_case during a backend rewrite) without introducing typos.
• API payload reshaping: convert camelCase JSON keys to snake_case before feeding them to a Ruby on Rails or Django backend, or to kebab-case for a CSS-in-JS class name.
• Headline and slug authoring: produce Title Case page titles, Sentence case meta descriptions, and kebab-case URL slugs from the same source headline in one step.

What does a case conversion example look like?

Paste Hello World API into the input. The result grid renders eleven rows simultaneously: helloWorldApi (camelCase), HelloWorldApi (PascalCase), hello_world_api (snake_case), HELLO_WORLD_API (CONSTANT_CASE), hello-world-api (kebab-case), hello.world.api (dot.case), hello/world/api (path/case), Hello World Api (Title Case), Hello world api (Sentence case), hello world api (lower case), and HELLO WORLD API (UPPER CASE). The same input pasted as helloWorldAPI tokenises to the same three words — the lowercase→uppercase boundary detector handles that shape too.

Does this run in my browser?

Yes. The tokeniser and the eleven case formatters are about 120 lines of vanilla JavaScript running inside the browser tab. Nothing is uploaded, no service worker proxies your input, and the page makes zero network requests for the convert step itself. The only outbound traffic is the standard page-load assets (CSS, fonts, analytics) — your text never reaches Ultim8Soft.

Which case format should I use for variable names?

It depends on the language and the team's style guide. JavaScript and TypeScript codebases overwhelmingly use camelCase for variables and functions, PascalCase for classes and React components, and CONSTANT_CASE for environment-variable names and module-level constants — the Google JavaScript style guide and the Airbnb style guide both pin those choices. Python (PEP 8), Ruby, and Rust prefer snake_case for variables and functions, PascalCase for classes, and CONSTANT_CASE for module-level constants. C and C++ codebases (Linux kernel, LLVM) lean on snake_case for functions and CONSTANT_CASE for preprocessor macros. When in doubt, run your team's linter or formatter — it will tell you which convention is enforced.

How is the input tokenised?

The tokeniser first splits the input on any run of whitespace, underscore (_), hyphen (-), dot (.), or slash (/). Each resulting chunk is then split again on lowercase→uppercase boundaries (so helloWorld becomes ["hello", "World"]) and on letter↔digit boundaries (so v2API becomes ["v", "2", "API"]). Empty tokens are filtered out, and the surviving tokens are lowercased via String.prototype.toLocaleLowerCase. The formatters then re-capitalise and re-join the tokens with the separator each target case requires. The strategy handles all six common identifier shapes — camelCase, PascalCase, snake_case, kebab-case, CONSTANT_CASE, and plain space-separated prose — out of the box.

What about Unicode / non-ASCII characters?

Unicode letters survive the round trip. The tokeniser uses String.prototype.toLocaleLowerCase and toLocaleUpperCase, which honour locale-specific casing rules — Turkish dotted vs dotless i, German ß upper-casing to SS, accented Latin letters in French and Spanish, and so on. Non-letter characters that are NOT in the separator set (whitespace, _, -, ., /) — for example digits, accented letters, or CJK characters — are kept inside the token they appear in and the case formatters re-emit them verbatim. This means an input like nœud_principal tokenises to ["nœud", "principal"] and converts cleanly to nœudPrincipal (camelCase) or NœudPrincipal (PascalCase).

This case converter is a single static page that runs the tokeniser and the eleven formatters entirely in your browser — no vendor library, no network call per conversion, no account. Paste any text above, scan the eleven case outputs side by side, and copy the one you need.