PascalCase Converter

PascalCase (sometimes called UpperCamelCase or StudlyCaps) is a naming convention where every word starts with an uppercase letter and there are no separators between words. It's the standard for class names, type names, and constructor functions in nearly every modern language.

The convention is named after the Pascal programming language (1970s), which used it for type names. The closely-related camelCase differs only in the first letter — PascalCase capitalises the first word; camelCase lowercases it.

When to use it

Class and type names

UserProfile, HttpClient, OrderRepository. Java, C#, TypeScript, Swift, Kotlin, and Python (PEP 8) all use PascalCase for class names regardless of what they use for variables.

React component names

React requires component names to be PascalCase — <UserCard /> not <userCard />. JSX uses the casing to decide whether a tag is a custom component (capitalised) or an HTML element (lowercase).

TypeScript interfaces and types

Interface names (UserSettings, ApiResponse) and type aliases are PascalCase. Some teams prefix interfaces with I (IUserSettings); the modern TypeScript convention is to skip the prefix.

Enum members

Most languages use PascalCase for enum members: OrderStatus.Pending, HttpStatus.NotFound. (Some older C++ code uses CONSTANT_CASE for enums; modern usage favours PascalCase.)

File names for class-defining files

If a file defines a class, the file name often matches the class name in PascalCase: UserProfile.tsx, OrderService.cs.

How the conversion works

The PascalCase converter parses the input string into tokens by splitting on all non-alphanumeric characters (spaces, hyphens, underscores, dots, etc.). Each token is then capitalised: the first character is uppercased, and the remaining characters are lowercased. The tokens are concatenated without any separator. This process follows the standard CamelCase capitalisation rule, but crucially it does not preserve all-uppercase acronyms — HTTPRequest becomes Httprequest (or HttpRequest if the input has word breaks). The algorithm uses Unicode-aware case mapping via the ECMA-262 String.prototype.toUpperCase() and toLowerCase() methods, which handle accented and non-Latin characters correctly. Numbers are treated as part of a token (e.g., user2background becomes User2background), not split into separate words.

How to use it

1. Type or paste your phrase into the input box.
2. Optionally, select any special delimiters to treat as word separators (hyphens, underscores, etc.).
3. Click the 'Convert' button or wait for auto-conversion.
4. Copy the resulting PascalCase text with the copy button.

Edge cases this converter handles

Acronyms

All-uppercase words like 'HTTP' are converted to normal capitalisation: 'Http' — not preserved as 'HTTP'.

Possessives

Apostrophes are removed and the word is treated as one: 'user's name' becomes 'UsersName' (the s remains lowercase).

Hyphenated words

Hyphens are treated as separators, so 'first-class' becomes 'FirstClass' — both parts are capitalised.

Pro tips for case conversion

• For acronyms you want to keep uppercase, manually wrap them with a separator trick: e.g., 'HTTP' → 'H T T P' then convert.
• Always lowercase the rest of each word to avoid mixed-case artifacts like 'userNAME' becoming 'Username' (correct).
• If your input contains digits, they are kept as-is; to treat digits as separate words, pre-insert a separator before each digit.
• Use this converter before pasting class names into C#, Java, or TypeScript to ensure consistent naming.

vs other ways to change case

While you can achieve PascalCase with text-manipulation tools, this dedicated converter is faster and handles edge cases automatically.

A bit of history

PascalCase derives its name from the Pascal programming language, designed by Niklaus Wirth in the late 1960s and first published in 1970. Pascal used this naming convention for type identifiers and record field names, promoting readability at a time when many languages used all-uppercase or cryptic abbreviations. The convention later spread to other languages like C# and TypeScript, where it became the standard for class names, methods, and properties. Its alternative name, UpperCamelCase, contrasts with lowerCamelCase used for variables and functions.