9314JIUsi
Text office · Composing stick

Set the case, ship the text

An email subject typed in all caps reads like shouting, and hand-renaming user_name to camelCase always drops a letter somewhere. Paste text into the left tray, pick a sort, and the right tray sets it instantly: 4 writer formats plus 5 developer naming styles, 9 in all. XMLParser splits into xml_parser - not x_m_l_parser. That detail is where the real work is.

COMPOSING STICK 9 sorts of type · awaiting copy
COPY · INPUT TRAY 0 chars · 0 words · 0 lines
SET · OUTPUT TRAY 0 chars · 0 words · 0 lines
Set type lands here. Paste on the left, pick a sort above, and it composes instantly.
chars 0 words 0 lines 0

Everything you type stays in this browser - zero network requests, and the text itself is never written to storage. Only your last-used mode is kept in this browser and disappears when you switch devices or clear site data. Use "Clear my data" in the footer to remove it.

Three moves of the stick

  1. Bring copyPaste text into the left tray (or hit "Set a sample"). Character, word and line counts light up live; anything over 1MB gets stopped with a plain reason.
  2. Pick a sortChoose a case from the rail above. The right tray re-sets instantly, with changed letters tinted so you can scan what actually moved.
  3. Take the typeCopy the result in one click, or download it as a .txt file. Switch sorts anytime - your input stays untouched in the left tray.

Why letter case is a real problem, not a cosmetic one

Two case failures I keep running into, years apart. First: a release email with the subject typed in ALL CAPS, which every mail client treats as shouting - open rates droop, and the fix is sentence case, not a rewrite. Second: a refactor that renamed forty snake_case columns to camelCase, where one missed letter means a property that silently reads as undefined and fails three screens away from the cause. Both problems are one paste away from being solved here.

What makes a converter hard is not uppercasing - that is one method call. It is splitting words back out once case and separators have done their job. XMLHttpRequest is three words to a human and a wall of letters to a naive splitter. Runners of capitals are the trap: XML, HTTP, JSON are single words, so the parser has to know that the capital starting "Parser" belongs to the next word, not the acronym. Get it wrong and you ship x_m_l_http_request.

This tool's tokenizer treats a run of capitals as one acronym and hands the final capital to the next word when lowercase letters follow it. So XMLParser lands as xml_parser, getJSON as get_json, parseJSONData as parse_json_data. It also accepts mixed input - snake, kebab, spaces and camel all at once - because real-world identifiers are never one convention.

The writer's four

Sentence case capitalizes only after a sentence ends - period, question mark, exclamation, or a newline - which is the register people actually read email and documentation in. lowercase and UPPERCASE are the workhorses: normalizing data before a comparison, or feeding the punchline of a headline. Title Case capitalizes content words and lowercases the small ones - a, an, the, of, and, or, but, in, on, at, to, for, and friends - while keeping the first word of the line capitalized, which is what most style guides actually ask for. (Chicago and AP disagree at the margins; no converter settles that argument.)

The developer's five

camelCase for JavaScript variables and function names; PascalCase for classes, types and components; snake_case for Python and SQL column names; kebab-case for CSS classes, HTML attributes and URL slugs; CONSTANT_CASE for environment variables and true constants. The differences sound pedantic until a lint rule rejects your pull request over one of them, or a teammate greps for user_data and finds nothing because the codebase says userData.

One honest pattern to know: camel, snake and kebab outputs are single identifiers - spaces and punctuation between words collapse into the joiner, because that is what an identifier is. Paste a sentence into snake_case and you get the_quick_brown_fox, which is what you wanted for a slug and definitely not a sentence anymore. The writer's four keep all spacing intact. Nothing is judged, everything is shown before you copy it.

Limits, stated plainly

Software cannot read minds about proper nouns. Sentence case folds NASA to nasa and Title Case lifts iphone to Iphone, because the machine has no dictionary of names worth trusting at this scale - the honest move is to let you touch those up by hand. Chinese, Japanese and Korean text carries no case at all, so it passes through untouched (this tool is built for English text; pure Chinese input returns unchanged). And the input cap is 1MB, about half a million English words, set so a pasted novel cannot freeze the tab rather than for any deep technical reason.

Facts and limits

InputPlain text (built for English: all 9 modes act on the 26 Latin letters; hanzi, emoji, digits and punctuation pass through unchanged)
Output9 modes: Sentence case / lowercase / UPPERCASE / Title Case / camelCase / PascalCase / snake_case / kebab-case / CONSTANT_CASE; live counts, copy, .txt download
DefaultsDefault mode Sentence case; Title Case keeps a small-word list (a/an/the/of/and/or/but/in/on/at/to/for etc.) lowercase except as the first word; naming modes smart-split input first (camel, snake, kebab and acronym runs all handled)
ProcessingLocal string processing in your browser - converting, counting, copying and downloading happen inside the page, zero network requests, no account; the text itself is never stored, only your last-used mode lives in this device's localStorage
Limits1MB (about one million characters) to keep the tab responsive; oversized input is rejected with a message to paste in parts
Known edgesMachines cannot spot proper names: Sentence case folds NASA to nasa, Title Case lifts iphone to Iphone - touch up acronyms and brand spellings by hand. Chinese has no case and is never affected (this tool targets English text)

FAQ

Why does XMLParser become xml_parser instead of x_m_l_parser?

The tokenizer treats runs of uppercase letters as one acronym: XML is one word, Parser is another, so you get xml_parser. Likewise getJSON splits into get and JSON. This is exactly where most case converters fail, so this tool carries dedicated acronym-splitting logic.

Does it break Chinese or other non-Latin text?

No. Chinese characters have no case, so the conversions only touch the 26 Latin letters - hanzi, CJK punctuation and emoji pass through untouched. Note the tool is built for English text; pasting pure Chinese simply returns it unchanged.

Will Sentence case capitalize every word?

No. Sentence case capitalizes only the first letter of each sentence and lowercases the rest, the way people normally write. Be aware that an acronym like NASA gets lowercased to nasa, because software cannot tell which words are proper names - use Title Case or touch it up manually when acronyms must stay uppercase.

What is the difference between camelCase and PascalCase?

Only the first word: camelCase keeps the first word lowercase and capitalizes the rest, like userName; PascalCase capitalizes every word, like UserName. JavaScript variables favor camelCase, while Java and C# class names favor PascalCase. The tool converts to both in one click.

What happens with text over 1MB?

It is rejected with a clear message. 1MB is roughly half a million English words, so normal use never hits the cap - the limit exists to stop a pasted novel from freezing the tab. Split very long text into a few passes.

Is my pasted text uploaded anywhere?

No. Converting, counting, copying and downloading all happen inside this device's browser - zero network requests, and the text itself is never written to local storage. Only your last-used mode is kept in this browser so the page opens the way you left it; the Clear my data link in the footer removes it.

Related tools