Skip to content

All tools (41)

JSON 6
Time & Date 4
Encoding & Decoding 4
Generators 3
Text & Data 4
Logs & Debugging 1
Config & Infra 3
Security & Hashing 4
Color & Design 5
Numbers & Bits 3
Web & Markup 4

Nothing leaves the cave.

Nothing you paste ever leaves your device. There is no server to send it to.

How you can check →
DevToolsCave

    This tool runs entirely in your browser. Nothing you paste is uploaded.

    How you can check →

    Case Converter

    Text & Data

    Convert text between sentence case, camelCase, snake_case, Title Case and 15 more — Unicode-safe, acronym-aware, and honest about when a conversion loses information.

    Graphemes: 0 Code points: 0 UTF-16 units: 0 UTF-8 bytes: 0 Words: 0 Lines: 0

    Transform in place

    Each button rewrites the text above in place, the way convertcase.net works. Undo keeps the last several states — a scripted rewrite otherwise clears the browser's own undo history.

    Options

    Turkish/Azerbaijani lowercase "I" to "ı" (dotless), not "i" — this tool never guesses your locale from your browser, so the same input always produces the same output on any machine.

    Acronym handling

    This tokenizer always keeps a run of capitals together: HTTPResponse → http_response.

    There's no toggle for the naive per-letter split (h_t_t_p_response) some other tools produce — that behaviour comes from a different, simpler regex splitter, not from an option on this one, and adding a second code path just to reproduce a bug would work against the acronym-safe tokenizer this whole tool is built on.

    Digit boundary rule

    A run of digits is always its own word and stays attached to the word on its left: utf8Decode → utf8_decode, user_id_2 → userId2.

    Libraries disagree here and there's no universal right answer (some would produce userIdV2) — this is a fixed, stated rule rather than a toggle, since the tokenizer every transform shares doesn't expose a second digit-handling mode.

    Every case, at once

    camelCase
    PascalCase
    snake_case
    CONSTANT_CASE
    kebab-case
    Train-Case
    dot.case
    path/case
    Capital Case
    no case
    Pascal_Snake_Case
    sWaP cAsE

    Nineteen cases, one tokenizer

    Every case convention in programming and writing comes from the same underlying decision: how do you split text into words, and how do you rejoin them? JavaScript's camelCase starts lowercase and capitalises every word after the first. Python's snake_case lowercases everything and joins with underscores. CSS's kebab-case does the same with dashes. SQL constants are traditionally CONSTANT_CASE — upper snake. Go exports a type as PascalCase. None of these are arbitrary: each grew out of what a particular language's parser or style guide would accept, and a developer who works across two or three of them converts by hand, constantly.

    The hard part isn't joining words back together — it's splitting them apart correctly in the first place. Most case converters split on every capital letter with a regex, and that breaks the moment an acronym shows up: parseJSONValue becomes the useless parse-j-s-o-n-value instead of parse-json-value, because a regex can't tell "a run of capitals is one acronym" from "each capital starts a new word". This tool's tokenizer treats a run of two or more capitals as a single unit — the acronym stays together, and only the last capital before a lowercase letter starts the next word. That's the difference between a converter that works on real code and one that only works on toy examples.

    Four title-case style guides, because they disagree

    "Title case" sounds like one rule; it's actually at least four competing ones, and the differences aren't cosmetic. AP style and APA capitalise any word of four letters or more, including prepositions like "About" and "After" — so "A Study About Sleep" is correct AP style. Chicago and MLA lowercase prepositions and articles at any length but capitalise subordinating conjunctions like "because" and "although" regardless of length — so the same sentence becomes "A Study about Sleep". A tool with a single "Title Case" button is right for half its visitors and silently wrong for the other half. This page ships all four, each with the exact rule stated beside the output rather than buried in a settings menu, plus an editable exceptions dictionary for the brand names and acronyms no rule table can guess.

    Why "straße" breaks the round trip

    Uppercasing German straße gives STRASSE — seven characters from six, because the letter ß has no uppercase form of its own in the traditional mapping and expands to two S's. Lowercase that back and you get strasse, not the original straße. A tool that markets UPPER and lower as exact opposites is quietly wrong the moment German text shows up, and the same trap catches ligatures (file uppercases to FILE, two characters becoming one) and the Greek final sigma (word-ending σ becomes ς, not the same letter it would be mid-word). Every writer-row transform on this page reports a receipt stating whether the result round-trips, and names ß specifically when it's the reason it doesn't.

    Why Turkish "I" breaks builds

    In Turkish and Azerbaijani, the uppercase of "i" is not "I" — it's "İ" (with a dot), and the lowercase of "I" is "ı" (without one). Call the wrong locale-sensitive case function on an identifier like Title.toLowerCase() using the visitor's browser locale instead of an explicit one, and a build that compiles fine in one office fails in another because the same source text produced two different strings. This tool never reads your machine's locale automatically — the locale option above is explicit, and "Invariant" (the default) uses the same case mapping on every machine regardless of where it's opened.

    Graphemes, code points, bytes: not the same number

    "How many characters is this?" doesn't have one answer once text stops being plain ASCII. A family emoji (👨‍👩‍👧) is one visible character — one grapheme — but five Unicode code points and more UTF-16 code units than that again once you count the invisible joiners holding it together. The four counters above this box are measured separately and labelled separately, because merging them into a single "characters" figure is exactly the kind of quiet imprecision that eventually breaks a fixed-width column or a VARCHAR limit that was sized off the wrong number.

    No headline score

    Some case-converter sites print a number claiming to grade a title's "emotional impact" or SEO strength. That number is not measured from anything — it's invented, and printing one we can't verify would be the exact failure this whole site exists to avoid. What you get instead is a receipt: how many characters actually changed, whether the length changed, and whether the transform is reversible. That's a fact about the text you typed, not a guess about how well it will perform.

    Frequently asked questions

    Why does this case converter keep acronyms together?
    Most case converters split on every capital letter, so parseJSONValue becomes parse-j-s-o-n-value. This tool's tokenizer treats a run of capitals as one unit, so it correctly produces parse-json-value and http_response instead of the broken per-letter split.
    Is UPPER CASE the opposite of lower case?
    Usually, but not for every language. German "straße".toUpperCase() becomes "STRASSE" — seven characters from six, because ß has no uppercase letter of its own. Lowercasing STRASSE back gives "strasse", not "straße". The receipt below states plainly when a conversion round-trips and when it doesn't.
    What does the character counter actually count?
    Four different, equally valid numbers: graphemes (what a person would call one visible character, including a multi-part emoji), Unicode code points, UTF-16 code units (what JavaScript's .length reports), and UTF-8 bytes (what a server actually stores). They agree for plain ASCII text and diverge the moment anything else appears.
    Which title case style guide should I use?
    AP and APA capitalise any word of four or more letters, including prepositions; Chicago and MLA lowercase prepositions and articles regardless of length but capitalise subordinating conjunctions like "because" and "although". APA is also the only one of the four where the last word isn't automatically capitalised. Pick the guide your publisher or style manual specifies — they genuinely disagree.
    Why is there no headline score or SEO grade?
    Because we can't verify one. A number claiming to measure a title's "emotional impact" or SEO strength is not a measurement, it's an invented confidence score, and printing one we didn't compute from a cited, published formula would be exactly the kind of false certainty this site exists to avoid.
    Does this tool send my text anywhere?
    No. Every transform, count and check runs in your browser. Nothing you type is logged, stored or transmitted.
    What happens to acronyms and proper nouns in Title Case?
    A run of capitals you typed (like NASA or API) is left exactly as typed rather than being lowercased and re-capitalised. For anything the automatic rules get wrong — a brand name, an unusual acronym — add it to the exceptions dictionary below the title-case panel; it's saved in your browser for next time.