Penukar Huruf Besar/Kecil

A free online case converter that runs entirely in your browser

This case converter instantly transforms your text into any case style you need — paste it in, pick a style, and copy the result in one click. There's nothing to install and no account to create: every conversion runs locally in your browser, so the text you convert is never sent to any server. Live counts for words, characters, sentences, lines and estimated reading time update as you type.

Whether you need to fix a headline stuck in ALL CAPS, convert UPPERCASE to lowercase, properly capitalize a title, or reformat a variable name from camelCase to snake_case, you can do it in a single click. Switch between all 15+ styles freely without losing your input text.

Fifteen+ text case styles in one tool

Everyday writing needs are covered by UPPERCASE, lowercase, Title Case, Sentence case and Capitalized Case (every word capitalized). Developers get the naming conventions they use daily — camelCase, PascalCase, snake_case, kebab-case, CONSTANT_CASE, dot.case and Train-Case. For edge cases there's aLtErNaTiNg, iNVERSE (toggle) and RaNdOm case.

The converter splits words intelligently, so myVariableName, my-variable-name and my variable name all convert correctly between every style without you having to pre-process the input. Most other converters handle 5–8 styles at most; this one covers over 15 in a single tool.

Smart Title Case with AP, APA, Chicago & MLA rules

Most converters get title case wrong by capitalizing every single word — ConvertCase.net and CaseConverter.com both do this, producing 'The Mystery Of The Missing Ruby' instead of the correct 'The Mystery of the Missing Ruby'. Real title case keeps minor words — articles, short conjunctions and prepositions — lowercase unless they start or end the title.

This tool does it properly and lets you choose the style guide that matches your work: AP and APA lowercase only short words of three letters or fewer (so 'With' stays capitalized), while Chicago and MLA lowercase all prepositions regardless of length. The first and last word are always capitalized, and the first word after a colon is too — making it a genuine replacement for dedicated headline capitalization tools.

Keep brand names and acronyms correct automatically

Brand names and acronyms are where naive converters consistently fail, turning iPhone into Iphone and NASA into Nasa. With Preserve names & acronyms on, this converter recognizes a built-in dictionary of common proper nouns — iPhone, iOS, macOS, JavaScript, TypeScript, GitHub, YouTube, PayPal, NASA, HTML, CSS, API and many more — and keeps their exact casing in Title, Sentence and Capitalized Case.

Add your own entries in the Custom terms box, one per line, and they'll always appear exactly as you typed them — perfect for product names, people's names and in-house acronyms that no generic dictionary would recognize. This feature alone makes this converter more useful than any spreadsheet function or word processor built-in.

How this converter compares to ConvertCase.net, CaseConverter.com, and Word

Online case converters vary significantly in quality. ConvertCase.net offers basic styles but no style-guide-aware title case and no acronym preservation. CaseConverter.com shows ads and limits some features behind a sign-up wall. capitalize.cc covers a handful of styles but stops at basic camelCase and kebab-case with no developer-specific options like dot.case or Train-Case. Microsoft Word's Shift+F3 shortcut cycles through only 3 styles (lowercase, UPPERCASE, Title Case) and requires the desktop app. Google Docs has no built-in developer case styles like snake_case or kebab-case.

This converter offers all 15+ styles free, with no ads, no uploads and no account — plus style-guide accuracy that desktop tools don't provide. It works on iPhone, Android, tablet and desktop equally well, making it the most complete free option available in a browser today.

Clean up text and read live stats

Text copied from PDFs, emails and spreadsheets often arrives with double spaces, stray line breaks and trailing whitespace. The built-in clean-up toggles let you trim spaces, collapse doubles into singles, remove line breaks or strip all spaces — all applied before the case conversion.

As you work, the live counter tracks words, characters, characters without spaces, sentences, lines and estimated reading time — making this also useful as a quick word counter for headlines, meta descriptions, tweets and any writing with a length limit. Everything updates in real time as you type or paste.

Private, instant and completely free

There's nothing to install and nothing to sign up for. Every conversion — from a single word to a full document — happens locally in your browser, so your text never leaves your device. Confidential documents, proprietary code, personal names and sensitive content all stay completely private. Bookmark the case converter and reach for it any time you need to change, capitalize or reformat text on any device.

Programming naming conventions: why every language chose a different case

camelCase joins multiple words by lowercasing the first word and capitalizing the initial letter of every subsequent word — myVariableName, getUserById. It is the dominant convention for variables and functions in JavaScript and TypeScript, and for instance fields and methods in Java and Swift. PascalCase (also called UpperCamelCase) follows the same logic but capitalizes the very first word too — MyComponent, UserProfile. JavaScript and TypeScript classes, React components and C# public members all use PascalCase, which lets editors and linters instantly distinguish a function call (render()) from a constructor call (new Renderer()).

snake_case lowercases every word and joins them with underscores — my_variable_name, user_first_name. Python's PEP 8 style guide mandates snake_case for all functions and variables, and SQL has adopted it for column names because SQL keywords are case-insensitive and an underscore-separated identifier like order_created_at scans better than a camelCase alternative. SCREAMING_SNAKE_CASE (also called CONSTANT_CASE) uppercases every letter and retains the underscores — MAX_RETRY_COUNT, API_BASE_URL — and is the standard way to denote compile-time or module-level constants in Python, C, C++, Java and many other languages, signaling to readers that the value must not be reassigned at runtime. kebab-case replaces underscores with hyphens and keeps everything lowercase — my-component, user-profile-card. Hyphens are not valid in most programming language identifiers, so kebab-case belongs to the web layer: HTML custom element names, CSS class names and custom properties, URL slugs, and Linux file names all favour kebab-case. Rust is worth highlighting as a language that enforces case style at the compiler level: the rustc compiler emits warnings when functions and variables are not snake_case or when types and traits are not PascalCase — a design decision that makes Rust codebases unusually uniform across the entire ecosystem.

Two rarer formats see use in specialised contexts. dot.case lowercases words and separates them with full stops — logging.root.level, spring.datasource.url. Java properties files, many configuration frameworks (Spring Boot, Typesafe Config) and some logging systems use dot.case because the dot naturally expresses a namespace hierarchy without requiring a separate syntax. Train-Case capitalizes the first letter of each word and joins them with hyphens — Content-Type, Accept-Encoding. HTTP/1.1 header field names are canonically Train-Case, which is why you see it in network tooling and some legacy CSS-in-JS naming schemes. Knowing when to reach for each style is part of working comfortably across languages, and a single tool that converts between all of them saves the repetitive mental arithmetic of counting hyphens, underscores and capital letters.

Unicode case conversion is harder than it looks

For plain ASCII text, case conversion is trivially simple: add 32 to the ASCII code to lowercase a letter, subtract 32 to uppercase it. The entire alphabet fits in two neat ranges — 65–90 for A–Z, 97–122 for a–z. But Unicode defines 1,114,112 code points, hundreds of which have case mappings that are non-obvious, context-dependent or locale-specific. Naively applying ASCII arithmetic to Unicode text corrupts non-Latin scripts and produces subtly wrong results that are hard to catch in testing.

The best-known trap is the Turkish and Azerbaijani dotted-I problem. In English, uppercase i is I, and lowercase I is i — simple. In Turkish, the rules are different: lowercase i (with dot) uppercases to İ (with dot), and uppercase I (without dot) lowercases to ı (without dot). A JavaScript call like 'istanbul'.toUpperCase() returns 'ISTANBUL' in most locales but 'İSTANBUL' when run in a Turkish locale — a difference that once caused a real production bug in a widely used open-source library when a lowercased content-type string failed a strict equality check in Turkish environments. The lesson is that locale-aware case conversion (which respects the user's regional rules) and locale-independent case conversion (which applies a single universal mapping) are genuinely different operations, and mixing them up silently breaks internationalised software.

German adds another wrinkle: the letter ß (Eszett or sharp S) is the only lowercase letter in common use that had no direct uppercase equivalent in traditional German orthography. Uppercasing Straße (street) conventionally produced STRASSE — two characters from one. The capital ẞ was formally added to the official German orthography in 2017, so a fully correct Unicode-aware converter can now produce STRAẞE, though many style guides still prefer the SS expansion. These edge cases are exactly why production localisation libraries such as ICU (International Components for Unicode) exist, and why rolling your own case conversion with a simple +32 offset is a maintenance hazard the moment your user base extends beyond English speakers.

URL case, SEO and the canonical lowercase convention

The HTTP specification states that URL paths are case-sensitive: /About and /about are technically two distinct resources, and Linux-based web servers (Apache, Nginx, most cloud hosting) treat them as such. A visitor who types /About will receive a 404 error if only /about exists. Windows and macOS file systems are historically case-insensitive, so IIS servers on Windows have masked this distinction for decades — a difference that causes genuine cross-platform deployment surprises when a site developed on a Mac is deployed to a Linux server for the first time.

Modern SEO practice is to use all-lowercase URLs universally and issue permanent HTTP 301 redirects from any uppercase variant to the lowercase canonical version. Google's crawler treats /About and /about as separate URLs with separate PageRank budgets unless a redirect or canonical tag unifies them, so a site that serves both forms is silently splitting its link equity. The slug generation recipe that follows from this is: lowercase the title, replace spaces and punctuation with hyphens, remove characters that are not alphanumeric or hyphens, and collapse consecutive hyphens — converting 'Best CSS Frameworks in 2025!' yields best-css-frameworks-in-2025. Stop-word removal (the, a, an, of, in) is optional and depends on whether the resulting slug is still readable and keyword-rich enough.

For search results themselves, Google is case-insensitive: a query for Case Converter returns the same results as case converter. However, the way a page title is cased affects its click-through rate. Studies by SEO platforms consistently show that headline-style title case (Free Online Case Converter — Uppercase, Lowercase & 15+ Styles) outperforms all-lowercase titles in desktop search results, because the mixed capitals pattern is more scannable and appears more authoritative in the blue-link list. Sentence case tends to win in mobile results where display space is narrower. Getting the case right on title tags and Open Graph titles therefore has a small but measurable impact on organic traffic — which is reason enough to want a fast, style-guide-accurate title case tool within arm's reach.

Why we call them 'uppercase' and 'lowercase': a brief history

The terms uppercase and lowercase are not metaphors — they are literal descriptions of physical objects. In moveable type printing, a compositor's workstation held two wooden cases (flat trays divided into small compartments, each holding one type character). The upper case sat at a steeper angle above the working surface and contained the less-frequently used capital letters; the lower case sat closer and flatter and held the small letters, punctuation, spaces and numbers that a typesetter needed to reach most often. Johannes Gutenberg's development of the moveable type press around 1440 made this dual-case layout the standard across Europe within decades, and the spatial names for the two character sets followed naturally. For 500 years, every printer's apprentice learned to 'reach for the upper case' when setting a capital — and the vocabulary outlasted the physical cases by centuries.

The concept of two separate forms for the same letter is not universal. Scripts are classified as unicameral (one form per letter) or bicameral (two forms). Arabic, Hebrew, Devanagari and Chinese are unicameral — there is simply no notion of a 'capital' form, which also means the entire question of case conversion is meaningless for text written in those scripts. Latin, Greek, Cyrillic, Armenian and Georgian are bicameral — each letter has a distinct uppercase and lowercase form developed over centuries of manuscript and print tradition. The distinction arose in Latin writing as scribes developed faster, more compact letterforms (minuscule) for everyday use while reserving the older monumental capitals (majuscule) for formal inscriptions and emphasis. The Carolingian minuscule, standardised under Charlemagne in the 8th–9th centuries, established essentially the modern Latin lowercase alphabet.

Early digital communication briefly reversed centuries of progress. Teletype machines and early terminals in the 1960s and 1970s supported only uppercase ASCII, because adding a second set of 26 characters would have required an extra bit in the 7-bit encoding scheme and doubled the memory required to store the character map — constraints that were non-trivial on hardware measured in kilobytes. Systems like the original ARPANET email protocols defaulted to all-caps because that was all the hardware could produce. The legacy of this era persists: email headers in the SMTP specification are case-insensitive (so Content-Type and content-type are equivalent) because the original authors could not assume a mail system was capable of consistent case handling. Understanding this history helps explain why casing conventions feel arbitrary across different technologies — they were each invented by people working within the constraints of a very specific moment in computing history.