Dot Case Converter

What Is Dot Notation?

Dot notation (also called dot case or dot separated format) is a naming convention where words are connected by periods instead of spaces or other separator characters. For example, "database connection settings" becomes database.connection.settings. The periods create a visual hierarchy that suggests nesting or categorization, making dot notation especially useful in contexts where you want to express relationships between terms.

Unlike snake case or camel case—which are primarily used for naming individual variables and functions—dot notation often carries semantic meaning. Each dot typically represents a level in a hierarchy. In configuration files, database.host suggests that "host" is a property nested under "database." In logging systems, auth.login.success tells you both the category (authentication), the action (login), and the outcome (success), all in one readable string.

The convention appears across many areas of software development. Python developers encounter it in module imports like os.path.join. JavaScript developers use it to access nested object properties like user.profile.settings. DevOps engineers write configuration keys like app.debug.mode. It's a natural way to express hierarchy in plain text, which is why it's so widely used despite not being tied to any single programming language.

Seven Case Styles at a Glance

• dot.notation: Lowercase words separated by periods. Used in configs, logging, namespaces, and property access. Example: user.profile.settings
• snake_case: Lowercase with underscores. The standard for Python, Ruby, and SQL identifiers. Example: user_profile_settings
• camelCase: First word lowercase, subsequent words capitalized. JavaScript and Java standard. Example: userProfileSettings
• PascalCase: Every word capitalized. Used for classes in C#, Java, and React components. Example: UserProfileSettings
• kebab-case: Lowercase with hyphens. CSS classes, URLs, and HTML attributes. Example: user-profile-settings
• SCREAMING_SNAKE: Uppercase with underscores. Universal standard for constants. Example: USER_PROFILE_SETTINGS
• flatcase: All lowercase, no separators. Used in some package names. Example: userprofilesettings

How the Dot Case Converter Works

Paste any text into the input field—whether it uses spaces, underscores, hyphens, camelCase, or even existing dot notation—and the intelligent detection system breaks it down into individual words. It recognizes patterns like capital letters in camelCase, underscores in snake_case, and existing dots in dot notation, ensuring that each word is correctly identified regardless of the input format.

Once the words are extracted, the converter reassembles them using your chosen output format. If you've selected dot notation, periods are inserted between each word. The optional uppercase mode converts everything to capital letters while preserving the dot separators—useful for environment variables or constants that follow a hierarchical naming pattern. You can also preserve numbers attached to words, so "version2" stays as one token rather than being split into "version" and "2."

Where Dot Notation Appears in Practice

Dot notation shows up in more places than you might expect. Here are the most common contexts where you'll encounter or want to use it:

• Configuration files: YAML, JSON, INI, and TOML files often use dot notation for nested keys. For example, database.host in a config file maps to a nested structure where "host" is inside "database."
• Logging systems: Structured logging libraries use dot-separated categories to organize log entries. auth.login.failure lets you filter logs by authentication failures specifically, without seeing successes or other auth events.
• Package namespaces: Java packages (com.example.project), npm scoped packages (@company/module), and Python namespace packages all use dot notation to organize code hierarchically.
• Environment variables: Some deployment systems use uppercase dot notation like APP.DATABASE.HOST for environment-specific configuration values.
• Routing and APIs: URL paths and API endpoint conventions sometimes mirror dot notation, using dots to indicate resource hierarchy.

Who Uses a Dot Case Converter?

• DevOps engineers: Generate configuration keys for deployment pipelines and environment-specific settings.
• Backend developers: Convert between dot notation in configs and snake_case in Python codebases.
• System administrators: Create structured logging categories and monitoring metric names.
• Full-stack developers: Transform API field names between JavaScript camelCase and configuration dot notation.
• Technical writers: Format namespace paths and configuration references consistently in documentation.

Key Features

• Seven output formats: dot.notation, snake_case, camelCase, PascalCase, kebab-case, SCREAMING_SNAKE, and flatcase.
• Intelligent input detection: Recognizes spaces, dots, underscores, hyphens, camelCase, PascalCase, and mixed formats.
• Uppercase dot notation: Optional conversion to UPPERCASE.DOT.FORMAT for environment variables and constants.
• Number preservation: Keep digits attached to words for versioned keys like "api.v2.users".
• Side-by-side comparison: See how your text looks in all seven formats at once.
• Input format detection: The tool identifies your input format and displays it in the statistics panel.
• Conversion history: Track recent conversions for easy reference.
• Sample presets: Quick-load config keys, logging categories, namespaces, and more.
• 100% private: All conversion in your browser.
• Completely free: No signup, no limits, no watermarks.

Conversion Examples

Here's how the same phrase transforms across all seven case styles:

Input: "Database Connection Settings For Production Environment"

• dot.notation: database.connection.settings.for.production.environment
• snake_case: database_connection_settings_for_production_environment
• camelCase: databaseConnectionSettingsForProductionEnvironment
• PascalCase: DatabaseConnectionSettingsForProductionEnvironment
• kebab-case: database-connection-settings-for-production-environment
• SCREAMING_SNAKE: DATABASE_CONNECTION_SETTINGS_FOR_PRODUCTION_ENVIRONMENT
• flatcase: databaseconnectionsettingsforproductionenvironment

Dot Notation Compared to Other Case Styles

What makes dot notation unique among the case styles is the semantic meaning of the separator. When you see underscores in snake_case or hyphens in kebab-case, the separator is purely cosmetic—it exists only to make multi-word identifiers readable. But dots carry additional meaning. They suggest hierarchy, nesting, and parent-child relationships between the words they separate.

This makes dot notation particularly valuable for configuration management and structured logging, where you want both readability and semantic structure in a single string. Our Snake Case Converter is the natural companion tool—when you need to take those dot-separated config keys and turn them into Python-compatible variable names, or vice versa. For more creative text transformations beyond the standard programming conventions, the Toggle Case Converter offers additional flexibility with its alternating case, sponge text, and custom pattern modes.