> ## Documentation Index > Fetch the complete documentation index at: https://mintlify.com/dolphin-emu/dolphin/llms.txt > Use this file to discover all available pages before exploring further. # Code Style Guide > C++ coding standards and formatting rules for Dolphin Emulator ## Overview Dolphin uses **clang-format 19.1** to enforce consistent code formatting across the entire codebase. This guide details the specific coding standards and formatting rules. In case of conflicts between this guide and clang-format rules, follow clang-format. ## Setting Up clang-format ### Automated Formatting Format all staged files before committing: ```bash theme={null} git diff --cached --name-only | grep -E '[.](cpp|h|mm)$' | xargs -I {} clang-format -i {} ``` Enable automatic formatting checks: ```bash theme={null} ln -s ../../Tools/lint.sh .git/hooks/pre-commit ``` Automatically reformat changes transparently: ```bash theme={null} git config filter.clang_format.smudge 'cat' git config filter.clang_format.clean 'clang-format %f' echo '/Source/Core/**/*.cpp filter=clang_format' >> .git/info/attributes echo '/Source/Core/**/*.h filter=clang_format' >> .git/info/attributes echo '/Source/Core/**/*.mm filter=clang_format' >> .git/info/attributes ``` Press `Ctrl+K` followed by `Ctrl+D` (or select **Edit → Advanced → Format Document**). Visual Studio has built-in clang-format support - no separate installation required. ### Line Endings Windows users must configure git to checkout UNIX-style line endings: ```bash theme={null} git config core.autocrlf input ``` ## General Formatting Rules ### Line Length and Indentation * **Maximum line length**: 100 characters * **Indentation**: 2 spaces per level (no tabs) * **Tab width**: 2 spaces Try to keep lines under 80-90 characters when possible for better readability. ### Brace Placement Opening braces go on the **next line** for: * Namespaces * Classes * Functions * Enums, structs, unions * Conditionals and loops ```cpp theme={null} // Correct void MyFunction() { if (condition) { DoSomething(); } } // Exception: Array initializers and lambdas can keep braces on same line auto lambda = [](int x) { return x * 2; }; int array[] = {1, 2, 3}; ``` ### Pointers and References Place the `*` or `&` against the **type name**, not the variable name: ```cpp theme={null} // Correct int* pointer; int& reference; // Incorrect int *pointer; int &reference; ``` ### Comments Use single-line comments (`//`), not multi-line comments (`/* */`): ```cpp theme={null} // This is correct // Multiple lines use multiple single-line comments /* This is incorrect */ ``` ### Conditionals and Loops Don't collapse single-line bodies onto the same line as the header: ```cpp theme={null} // Correct if (condition) return 0; while (var != 0) var--; // Incorrect if (condition) return 0; while (var != 0) var--; ``` ## Naming Conventions ### Classes, Enums, Functions, Structs Use **UpperCamelCase**. Uppercase abbreviations: ```cpp theme={null} class SomeClassName { }; enum IPCCommandType { }; void ProcessRequest(); struct GameMetadata { }; ``` ### Constants Fully uppercase with underscores: ```cpp theme={null} constexpr double PI = 3.14159; constexpr int MAX_PATH = 260; ``` ### Variables Lowercase with underscores: ```cpp theme={null} int this_variable_name; float player_speed; ``` ### Variable Prefixes Do not use Hungarian notation except for these specific prefixes: | Prefix | Usage | Example | | ------ | ---------------------- | ------------------ | | `g_` | Global variables | `g_video_backend` | | `m_` | Class member variables | `m_width` | | `s_` | Static variables | `s_instance_count` | ```cpp theme={null} class ExampleClass { private: int m_x; // Member variable static int s_instance_count; // Static variable }; int g_global_counter; // Global variable ``` ## Conditional Statements Don't leave `else` or `else if` dangling unless the `if` lacks braces: ```cpp theme={null} // Correct if (condition) { // code } else { // code } // Also acceptable if (condition) // single line else // single line // Incorrect - inconsistent bracing if (condition) { // code } else // single line ``` ## Classes and Structs ### When to Use Each * **`struct`**: Use for [POD (Plain Old Data)](https://en.wikipedia.org/wiki/Passive_data_structure) types * **`class`**: Use for everything else ### Class Layout Order sections as: `public`, `protected`, `private` Within each section, order as: 1. Constructor 2. Destructor 3. Operator overloads 4. Functions 5. Variables (static before non-static) ```cpp theme={null} class ExampleClass : public SomeParent { public: ExampleClass(int x, int y); ~ExampleClass(); int GetX() const; int GetY() const; protected: virtual void SomeProtectedFunction() = 0; static float s_some_variable; private: int m_x; int m_y; }; ``` ### Final and Override Specifiers Mark classes/functions that shouldn't be inherited/overridden with `final`: ```cpp theme={null} class ClassName final : ParentClass { public: void Update() final; // Cannot be overridden }; ``` Mark overridden functions with `override`: ```cpp theme={null} class ClassName : ParentClass { public: void Update() override; // Overrides parent's Update() }; ``` ## Code-Specific Guidelines ### Modern C++ Practices Use `nullptr` instead of the `NULL` macro: ```cpp theme={null} int* ptr = nullptr; // Correct int* ptr = NULL; // Incorrect ``` Use range-based for loops over iterators when possible: ```cpp theme={null} for (const auto& item : container) { // process item } ``` Prefer STL containers and smart pointers: ```cpp theme={null} std::vector data; // Instead of int* std::unique_ptr