Text Case Format Converter

Why convert offline?

Most case conversion tools are server-backed. When you paste text into them, the full string, which might contain variable names, internal code snippets, or identifiers you would rather keep private, is transmitted to a third-party server. For developers working with proprietary code or writers handling confidential drafts, that round trip is a meaningful privacy risk.

This tool uses vanilla JavaScript running entirely in your browser, so the text you paste never leaves your machine. All 14 case transformations happen locally using pure string manipulation applied character by character and word by word.¹ You can verify this yourself by opening DevTools, switching to the Network tab, and watching for outbound requests as you type: there are none, no matter how much text you process.

How local execution protects your text

Nothing you paste is read by any other machine, because the conversion code runs as plain JavaScript inside your page and never opens a network socket or writes anything to disk. That means variable names, configuration keys, and confidential identifiers stay on your device from the moment you type them to the moment you copy the converted result into your clipboard. There is no backend, no analytics call, and no hidden telemetry that could leak what you are working on.

Character case formats

The first table shows 5 character-level transformations. Each one works on every character in the string regardless of word boundaries, so the output depends only on the case of each individual letter and not on any detection of where one word ends and the next begins. There is no splitting step, which makes these formats fast and predictable even when the input is a single long token with no separators.

When to pick a character-level format

Choose a character-level format when you want a uniform transformation applied across the entire input, rather than a format that depends on splitting the text into words first. That makes them the natural fit for case-insensitive normalisation, for emphasis and stylised text in headings or messages, and for any situation where the structure of the input should not change.

• lower case. Converts every letter to lowercase. Use: normalizing user input, preparing strings for case-insensitive comparison, standardizing display text.
• UPPER CASE. Converts every letter to uppercase. Use: constants in programming, environment variables, SQL keywords, emphasis in headings.
• Capitalized Case. Makes the first character of each word uppercase and the rest lowercase. Use: proper nouns in prose, formatting names or titles in user-facing text.
• aLtErNaTiNg cAsE. Flips each character in sequence, so even positions become lowercase and odd positions become uppercase. Use: stylistic text effects, meme formatting, visual emphasis in informal contexts.
• InVeRsE CaSe. Swaps the case of every character, turning uppercase into lowercase and lowercase into uppercase. Use: stylistic text effects and obfuscating text while keeping it readable.

Word case formats

The second table shows 9 word-level transformations, each of which alters how words are recognised and rebuilt rather than how individual letters are cased. Understanding how the tool splits a string into words is the key to predicting what each output will look like, especially when the input mixes several separator styles or contains compound identifiers.

How word splitting works

Splitting recognises explicit separators (spaces, underscores, hyphens, dots, and slashes) and implicit compound identifier boundaries at the same time. It flags lowercase-to-uppercase transitions inside a run of letters, letter-to-digit transitions, and acronym edges where a sequence of capitals meets a following capitalised word. Because of that detection, getHTTPCode produces get / http / code and userID produces user / id without any manual cleanup, and mixed inputs such as hello_world-test still resolve into a clean word list before the joining step runs.

• camelCase. Lowercases the first word and capitalizes every subsequent word. Use: JavaScript identifiers and object keys, where project style often normalizes names before data moves between systems.²³
• PascalCase. Capitalizes every word in the identifier. Use: C# and .NET types and members, where Microsoft's guidelines use PascalCasing for public member, type, and namespace names.⁴
• snake_case. Joins every word with an underscore. Use: Python variables, functions, and module names, where PEP 8 recommends lowercase with underscores.⁵
• SCREAMING_SNAKE. The same as snake_case, but rendered in all capital letters. Use: constants and portable POSIX utility environment variables, where names use uppercase letters, digits, and underscores.⁶
• kebab-case. Joins every word with a hyphen. Use: CSS custom properties, where the CSS variables spec uses dashed names such as --main-color.⁷
• dot.case. Joins every word with a dot. Use: Java package names (com.example.app), configuration keys, semantic versioning references.
• path/case. Joins every word with a forward slash. Use: file system paths, URL path segments, directory structures, routing patterns.
• sentence case. Capitalizes only the first word and lowercases the rest. Use: prose sentences, user-facing messages, email body text, captions.
• Title Case. Capitalizes every word in the string. Use: headings, book titles, navigation labels, button text, card titles in UI design.

Chaining conversions

The "Use as input" button next to each row lets you chain transformations. Click it and the converted text becomes the new input, so the tool immediately recalculates all 14 formats based on the updated text. This is useful when you need to go from one format to another that the tool doesn't support directly. For example, you can start with a snake_case variable, convert it to camelCase, and then use that result as the input to produce kebab-case in a second step.

CapyToolkit offers this chaining workflow because real-world text transformations rarely fit inside a single conversion. Variable names move between languages when Python snake_case needs to become JavaScript camelCase. URL slugs evolve when a Title Case heading should become a kebab-case path for SEO. Configuration keys get normalized across systems when a dot.case property needs to turn into a SCREAMING_SNAKE constant. Chaining lets each of those shifts happen in place without losing the intermediate result.

Variable naming conventions across languages

Different ecosystems make casing part of their conventions. Python's PEP 8 recommends lowercase function and variable names with underscores, while JavaScript guidance uses camelCase for function names and PascalCase for class names.²⁵ Microsoft's .NET guidance uses PascalCasing for public member, type, and namespace names and camelCasing for parameter names.⁴ CSS custom property names start with two dashes, and the CSS variables spec shows dashed names such as --main-color.⁷

Moving code between these worlds is where conversion earns its place in a workflow. Copying a Python REST API response into a TypeScript interface means every snake_case field needs camelCase treatment before the types compile. Generating CSS variable names from a Figma token list means converting Title Case labels to kebab-case before they work as custom properties. Exporting database column names to an ORM model means snake_case columns become camelCase or PascalCase properties depending on the ORM's convention. Each step is mechanical, but doing it manually across dozens of identifiers invites slip errors that take real time to trace through compiled output and failing tests.

Configuration files and data formats add another layer. JSON object names are strings rather than a mandated casing scheme, while portable POSIX utility environment variables use uppercase letters, digits, and underscores.³⁶ A single project can pull data from multiple formats and require consistent naming before any of the data can be joined or compared. Converting 30 field names at once rather than one by one is the kind of mechanical task that costs seconds with the right tool but breaks focus for far longer when done by hand. CapyToolkit's Text Case Format Converter handles all 14 formats in a single pass, so you pick the target format and every output updates simultaneously.