Naming a class, a component or a C# type? This free PascalCase converter turns any phrase — “user first name”, “user-first-name”, “userFirstName” — into clean PascalCase like UserFirstName, ready to paste into code.
Conversion happens entirely in your browser, so your text never leaves your device. For the lowercase-first twin, use the camelCase Converter, or fix the casing first with the Title Case Converter.
How to use
- Type or paste your text into the box above.
- The PascalCase version appears instantly in the output box.
- Use Copy result to copy it, or Clear to start over.
Why use Toolsvine
Class and component names are the first thing another developer reads in your code, and PascalCase is the agreed style in C#, Java, TypeScript and React. This converter applies the rules the same way every time, so names stay consistent across the whole codebase. The worked example shows exactly what happens to numbers, hyphens and acronyms, so there are no surprises.
What is PascalCase?
PascalCase is a naming style where words are joined with no spaces and every word starts with a capital letter: UserFirstName, LoginForm, OrderService. The first letter is capitalized, which is the only difference from camelCase — and it is the signal other developers read first, because PascalCase names are types and components, not variables.
The converter splits your text on spaces, hyphens, underscores and other separators, and also at lower-to-upper-case boundaries, so “userFirstName” and “user first name” give the same result. Every word starts with a capital letter and the rest stays lowercase, and the words are joined with nothing between them. Digits stay where they are — “version 2 update” becomes Version2Update.
Where PascalCase is used
| Place | Example |
|---|---|
| Class names | UserAccount |
| React components | LoginForm |
| C# types | OrderService |
| Enum values | PaymentStatus |
PascalCase vs camelCase
The only difference is the first letter: PascalCase starts uppercase (UserName), camelCase starts lowercase (userName). Classes and components take PascalCase; variables and functions take camelCase — keeping the two apart makes code easier to scan at a glance.
Worked example: three phrases, three names
Type “user first name” and the converter returns UserFirstName: every word is capitalized and joined with no spaces. Type “Monthly Sales Report” and the result is MonthlySalesReport — the capitals you typed are ignored, because every word is lowercased first and then re-capitalized by position.
Numbers and separators behave the same way. “version 2 update” becomes Version2Update, with the digit kept in place, and “user-first-name” or “user_first_name” both become UserFirstName, because hyphens and underscores are treated as word separators and removed. An acronym shows the one surprise: “HTTPResponseCode” becomes HttpResponseCode, because the whole run of capitals is lowered first and each word boundary is then re-capitalized by position.
| Input | PascalCase |
|---|---|
| user first name | UserFirstName |
| Monthly Sales Report | MonthlySalesReport |
| version 2 update | Version2Update |
| user-first-name | UserFirstName |
| HTTPResponseCode | HttpResponseCode |
What mistakes should I avoid with PascalCase?
The most common mistake is using PascalCase where camelCase belongs. JavaScript variables, functions and JSON keys take camelCase — userName, getUserById, createdAt — while classes and components take PascalCase. A variable named UserName will not break your build, but it will confuse every developer who reads it, because the casing is the signal for what the name is.
A second mistake is feeding the tool acronyms and expecting them to survive. “HTTPResponseCode” becomes HttpResponseCode, not HTTPResponseCode with HTTP intact, because the converter lowercases the whole acronym first. If an acronym must stay visible, rename by hand afterwards — or accept the lowered form, which is what most style guides recommend anyway.
Frequently asked questions
Is my text uploaded anywhere?
No. The conversion runs entirely in your browser with JavaScript. Your text never leaves your device, and the tool works offline once the page has loaded. That makes it safe for code names, project labels and any text you would never paste into a stranger's server.
What is PascalCase?
A naming style where words are joined with no spaces and every word starts with a capital letter: UserFirstName, LoginForm, OrderService. The first letter is capitalized, which is the only difference from camelCase. It is the standard style for classes and components in C#, Java, TypeScript and React.
How are hyphens and underscores handled?
They are treated as word separators and removed. “user-first-name” and “user_first_name” both become UserFirstName. The same applies to dots, slashes and other punctuation: any run of non-letter characters splits the words, so “user.first.name” becomes UserFirstName as well. That is why mixed input such as “user first-name_here” still converts cleanly to a single name.
What happens to numbers?
Digits are kept in place. “version 2 update” becomes Version2Update, and “html5 parser” becomes Html5Parser. A digit does not start a new capitalized word, so “2” stays attached to the word before it and the word after it takes its capital from the normal rule.
What is the difference from camelCase?
Only the first letter: PascalCase starts uppercase (UserName), camelCase starts lowercase (userName). Use the camelCase Converter for variables and functions, and PascalCase for class and component names. Mixing them up will not break a build, but it confuses anyone reading the code.