[GPE] Coding Style Discussion: gp vs GP Naming Convention (C/C++)

[mallory-scotton]

Hi everyone 👋

Following the discussion in the initial coding style issue, I’d like to gather broader feedback on the preferred naming convention for the engine.

The main question is:

Do you prefer lowercase (gp) with snake/c-style naming, or uppercase (GP) with PascalCase? (original one, but with enhancements, see docs)

---

Option A: gp (lowercase + STL-like style)

This approach is closer to STL / modern C++ conventions.

bool gp::application::start()
{
    gp::math::vec2<gp::u32> size(1920, 1080);
    gp::rhi::device device = gp::rhi::device::create();
    gp::hal::window window(size, "Graphical Playground");

    if (!window.is_valid())
    {
        gp::error::raise(gp::error::fatal, "Window creation failed");
        return false;
    }

    window.bind_device(device);

    bool is_initialized = device.initialize(gp::rhi::backend::vulkan);
    if (!is_initialized)
    {
        gp::error::raise(gp::error::fatal, "Device initialization failed");
        return false;
    }

    window.onClosed += [](const auto&) { gp::hal::request_exit(); };

    while (window.isOpen())
    {
        gp::hal::poll_system_events();
        device.present();
    }
}

✅ Pros	❌ Cons
Familiar to C++ developers (STL-like)	Can feel less “engine-like” or less explicit
Consistent with lowercase namespaces (std, etc.)	Harder to visually distinguish types vs functions
More compact / less visual noise

---

⚡ Option B: GP (PascalCase / Unreal-like style)

This approach is closer to engines like Unreal / enterprise C++.

bool GP::Application::Start()
{
    GP::Vector2<GP::UInt32> size(1920, 1080);
    GP::RHI!!Device device = GP::RHI::Device::Create();
    GP::Window window(size, "Graphical Playground");

    if (!window.IsValid())
    {
        GP::RaiseError(GP::EErrorType::Fatal, "Window creation failed");
        return false;
    }

    window.BindDevice(device);

    bool isInitialized = device.Initialize(GP::EBackend::Vulkan);
    if (!isInitialized)
    {
        GP::Error::Raise(GP::Error::EType::Fatal, "Device initialization failed");
        return false;
    }

    window.OnClosed += [](const auto&) { GP::Platform::RequestExit(); };

    while (window.IsOpen())
    {
        GP::Platform::PollEvents();
        device.Present();
    }
}

✅ Pros	❌ Cons
Very explicit and readable	More verbose
Clear distinction between types, methods, enums	Less aligned with standard C++ ecosystem
Feels like a “full engine framework”
Well documented, see docs

🧬 Extended Example: Core Types

gp style

namespace gp
{

using u32 = uint32_t;

template <typename T> class vector;

namespace math
{
    template <typename T> struct vec3;
}

}

GP style

namespace GP {

using UInt32 = uint32_t;

template <typename T> class Vector;

namespace Math
{
    template <typename T> struct Vector3;
}
}

---

💬 Discussion Points

• Which style improves readability at scale?
• Which one is better for API design / public exposure?
• Does consistency with C++ ecosystem vs game engines matter to you?
• Any long-term maintainability concerns?

---

Thanks for your feedback 🙌

[mallory-scotton]

An other solution is to have a new coding style that utilize:

• PascalCase for classes, namespaces and types.
• lowerCamelcase for variables and arguments and prefixes for static (s_) or private (m_) members.
• lowerCamelCase (this has changed from PascalCase) for methods !

prefixes for classes types (optional, can get confusing over time):

• IMyInterface for interfaces
• EMyEnum for enums
• TMyClass for templated classes
• FMyClass for forwarded classes
• MyClass for everyday classes

namespace GP::Math
{

template <GP::Concepts::IsFloatingPoint T> // or GP::IsFloatingPoint
struct Matrix4x4
{
private:
    GP_ALIGNAS(16) T m_data[16];
    
public:
    ...
    
public:
    GP_NODISCARD constexpr Matrix4x4<T> getRowMajor() noexcept {...}
    GP_NODISCARD constexpr Matrix4x4<T> getColumnMajor() noexcept {...}
};

}

int main(int argc, char* argv[])
{
    GP::Application application;
    
    application.processArguments(argc, argv);
    auto window = GP::Platform::Window::Create();
    
    GP::Math::Matrix4x4<GP::Float32> transform;
    
    window.setTransform(transform.getRowMajor());
    
    while (window.isOpen())
    {
        GP::Platform::PollSystemEvents();
        window.dispatchEvents();
        window.display();
    }
}

WDYT ?

PS: Or an alternative will be to keep namespaces single-word and in lowercase to contrast between the Classes and the namespaces (add an emoji to this post if you agree with this)

[Hugo-Cathelain]

This looks great !

A mix of both sounds good to me.

[Omegalpha28]

Nicehhhh, while the first option is certainly faster to code, the second seems offers better readability. Since our goal is to build an 'open' engine, I guess it's better to prioritize an approach that facilitates understanding for future contributors right from the start even if it requires a slight learning curve at first, the second visual structure allows for instant identification of each element's role, which will greatly simplify long-term maintenance (that's a good things for me xD).

[mallory-scotton]

Thanks for your response @Omegalpha28, what do you think about my proposition in the previous comments to allow both PascalCase for objects (struct, class, enum) and to keep the rest: methods, namespace, members in lowerCamelCase ?
And what do you think about the prefixes in front of the classes for the interfaces, enums, forward and templated ?