# Swift Naming Conventions: camelCase, PascalCase, and Constants Source: https://devdocs10.com/articles/swift/swift-naming-conventions By Murat Bo · Published 2026-06-18 · DevDocs10 (https://devdocs10.com) Swift naming conventions help you write code that is easier to read, easier to maintain, and more consistent with the rest of the language. This article explains how Swift prefers names for types, variables, functions, properties, enum cases, and constants so your code looks idiomatic and professional. > **Quick answer:** Use `camelCase` for variables, functions, and properties; use `PascalCase` for types like `struct`, `class`, `enum`, and `protocol`; and use clear, meaningful names for constants declared with `let`. > **Difficulty:** Beginner > > **Helpful to know first:** You'll understand this better if you know basic Swift syntax, how `let` and `var` work, and the difference between types and values. ## 1. What Is Swift Naming Conventions? Swift naming conventions are the style rules developers follow when choosing names for code elements. Swift does not force most naming styles, but the language and its standard library strongly encourage specific patterns so code stays readable and predictable. - `camelCase` starts with a lowercase letter and capitalizes later words, such as `userName` or `calculateTotal`. - `PascalCase` capitalizes every word, including the first one, such as `UserProfile` or `NetworkError`. - Constants declared with `let` should have descriptive names that communicate meaning, not just that they are fixed values. - Swift prefers names that read naturally and avoid unnecessary abbreviations. - Names should describe what something is or does, not how it is implemented. In practice, naming conventions are part language style and part communication tool. Good names let other developers understand your code before they read the implementation. ## 2. Why Swift Naming Conventions Matter Clear naming is one of the fastest ways to make Swift code easier to work with. A well-named variable or type can eliminate the need for comments, reduce mistakes, and make APIs feel more natural to use. Swift also uses naming as part of its design philosophy. Many standard library APIs read like English sentences, which makes call sites easier to understand. - Readable names reduce cognitive load during reviews and debugging. - Consistent casing helps you instantly recognize whether something is a type, value, or function. - Meaningful constant names make code safer because they explain the purpose of the value. - Good names improve autocomplete results and searchability in large codebases. Bad naming often becomes a hidden cost. A confusing name may compile perfectly but create repeated misunderstandings every time someone revisits the code. ## 3. Basic Syntax Swift naming conventions are not special syntax, but they are essential style rules. The most common patterns are simple: ### Variables and functions use camelCase Use lowercase for the first word and capitalize each new word after that. ```swift let userName = "Ava" func printGreeting() { print("Hello!") } ``` Here, `userName` and `printGreeting` follow the standard Swift style for values and functions. ### Types use PascalCase Type names begin with a capital letter and capitalize each word. ```swift struct UserProfile { let displayName: String } ``` This makes type names stand out from variable names at a glance. ### Constants use clear descriptive names Use `let` when a value does not need to change, and name it by purpose. ```swift let maximumLoginAttempts = 3 let welcomeMessage = "Welcome back" ``` The key idea is consistency: the name should match the role of the symbol in your code. ## 4. Step-by-Step Examples The best way to learn Swift naming conventions is to see how they apply in real code. The examples below show the most common cases you will write every day. ### Example 1: Naming a variable A variable that stores a user's first name should be descriptive and lowercase at the start. ```swift var firstName = "Mia" print(firstName) ``` Output (tested with Swift 6.4): ```text Mia ``` This is preferred over short or unclear names like `fn` because it immediately tells you what the value contains. ### Example 2: Naming a function Function names should describe an action, usually with a verb. ```swift func calculateTotalPrice(subtotal: Double, taxRate: Double) -> Double { return subtotal + (subtotal * taxRate) } ``` The function name is explicit, and the parameters also use lowercase camelCase for consistency. ### Example 3: Naming a type Types should be written in PascalCase so they are easy to identify. ```swift enum PaymentStatus { case pending case paid case failed } ``` The type name `PaymentStatus` clearly represents a category, while the cases use lower camel case. ### Example 4: Naming a constant A constant should communicate meaning instead of just saying it cannot change. ```swift let minutesPerHour = 60 let supportEmail = "help@example.com" ``` These names are clear, stable, and easy to reuse in later code. ## 5. Practical Use Cases Swift naming conventions show up in almost every file you write. They are especially important in codebases with many collaborators. - Model types like `UserAccount`, `InvoiceItem`, and `NetworkResponse`. - Stored properties like `emailAddress`, `isEnabled`, and `itemCount`. - Utility functions like `loadProfile()`, `formatDate()`, and `validatePassword()`. - Constants like `apiBaseURL`, `retryDelaySeconds`, and `defaultPageSize`. - Enum cases like `.success`, `.offline`, and `.unknown`. These naming patterns also help with code completion. When names are consistent, the right symbol is easier to spot. ## 6. Common Mistakes Most naming bugs in Swift are not compiler errors, but they still make code harder to read and maintain. The mistakes below are some of the most common ones. ### Mistake 1: Using PascalCase for variables and functions Beginners sometimes capitalize every word in a variable or function name because they assume all words should look like type names. In Swift, that makes the code look unusual and less idiomatic. **Problem:** This code compiles, but the names break Swift's usual style and make values look like types. ```swift let UserName = "Noah" func PrintGreeting() { print("Hello") } ``` **Fix:** Use lower camel case for values and functions. ```swift let userName = "Noah" func printGreeting() { print("Hello") } ``` The corrected version matches Swift conventions and makes the symbol roles easier to recognize. ### Mistake 2: Using unclear abbreviations Short names may save typing, but they often cost more time later when you need to remember what they mean. **Problem:** Names like `usr` and `qty` are compact but too vague in larger codebases. ```swift let usr = "Ada" let qty = 12 ``` **Fix:** Prefer names that spell out the meaning clearly. ```swift let userName = "Ada" let quantity = 12 ``` The corrected names are easier to scan, search, and understand without context. ### Mistake 3: Naming constants like temporary values Constants should sound stable and purposeful. Names that look like throwaway temporary values make code feel less intentional. **Problem:** A constant named `temp` or `value1` does not explain what the data is for. ```swift let temp = 30 let value1 = "OK" ``` **Fix:** Name the constant after its meaning in the program. ```swift let defaultTemperature = 30 let statusMessage = "OK" ``` Meaningful constant names make the code self-documenting and reduce the need for comments. ## 7. Best Practices Good naming is not only about casing. It is also about consistency, clarity, and matching Swift's style and API design conventions. ### Practice 1: Use nouns for data and verbs for actions Variables and properties usually represent things, while functions usually perform actions. ```swift let userAge = 18 func sendEmail() { // send mail here } ``` This convention makes symbols easier to classify just by reading them. ### Practice 2: Keep Boolean names readable as questions or states Boolean values are easier to use when their names imply true or false clearly. ```swift let isLoggedIn = true let hasPermission = false ``` Names that begin with `is`, `has`, or `can` often read naturally in conditions. ### Practice 3: Match the surrounding API style Swift code often reads best when related names follow the same pattern. ```swift let minimumPasswordLength = 8 let maximumPasswordLength = 64 ``` Paired names become easier to compare when they share structure and wording. ## 8. Limitations and Edge Cases Swift naming rules are flexible, but there are a few situations where the conventions can feel less obvious. - Type names should usually be PascalCase, but generic placeholders like `Element` or `Key` are still type names even when they are short. - Enum cases use lower camel case, not PascalCase, even though the enum itself uses PascalCase. - Imported APIs from Apple frameworks may not perfectly match Swift style, and you should usually preserve the official API name at the call site. - Two words that begin with an acronym can be tricky; Swift style generally favors readable names like `apiBaseURL` over awkward all-caps variants inside the name. - Property wrappers, closures, and local constants still follow the same general naming rules, even when the syntax around them looks different. A useful rule is that the more public the code is, the more important consistent naming becomes. Internal helper names still matter, but public APIs carry the most long-term impact. ## 9. Practical Mini Project Let's build a small Swift file that demonstrates naming conventions in a realistic way: a simple product model, a pricing function, and a formatted summary string. ```swift struct Product { let name: String let basePrice: Double } func finalPrice(for product: Product, taxRate: Double) -> Double { return product.basePrice + (product.basePrice * taxRate) } let featuredProduct = Product(name: "Notebook", basePrice: 12.50) let taxRate = 0.08 let price = finalPrice(for: featuredProduct, taxRate: taxRate) print("\(featuredProduct.name) costs \(price) after tax.") ``` Output (tested with Swift 6.4): ```text Notebook costs 13.5 after tax. ``` This example uses PascalCase for the type `Product`, camelCase for the function `finalPrice`, and clear lowercase names for values like `featuredProduct` and `taxRate`. The result is code that reads naturally and is easy to extend. ## 10. Key Points - Use camelCase for variables, properties, and functions. - Use PascalCase for types such as structs, classes, enums, and protocols. - Use descriptive names for constants declared with `let`. - Prefer meaningful words over abbreviations that save only a little typing. - Choose names that communicate purpose, not implementation details. ## 11. Practice Exercise Rewrite the following symbols so they follow Swift naming conventions: - A type for storing book information - A constant for the maximum number of retries - A function that returns whether a user can edit a post - A Boolean value that tracks whether the document is saved **Expected output:** The names should use PascalCase for the type and lower camel case for the values and function. **Hint:** Ask yourself whether each name describes a type, a value, or an action. **Solution:** ```swift struct BookInfo { let title: String let author: String } let maximumRetries = 3 func canEditPost(userRole: String) -> Bool { return userRole == "editor" } let isDocumentSaved = true ``` This solution follows Swift's naming style and makes each symbol's purpose obvious. ## 12. Final Summary Swift naming conventions are a small part of the language, but they have a big effect on how readable and maintainable your code feels. Using `camelCase` for values and functions, `PascalCase` for types, and meaningful names for constants gives your code a clean, familiar Swift style. Good names are not just cosmetic. They help readers understand intent, reduce confusion in reviews, and make APIs easier to use correctly. When you choose names carefully, your code becomes more self-explanatory and easier to evolve over time. As a next step, practice renaming existing Swift code in a small project. Focus on making names more specific, more consistent, and more natural to read.