GLFW+OpenGL3 Example handles DPI correctly but, same example code in my project does not

[ExoticGamerrrYT]

Version/Branch of Dear ImGui:

Version 1.92.4, Branch: docking

Back-ends:

imgui_impl_opengl3.cpp + imgui_impl_glfw.cpp

Compiler, OS:

Windows 11 + MSVC 2022

Full config/build information:

Dear ImGui 1.92.4 WIP (19234)
--------------------------------

sizeof(size_t): 8, sizeof(ImDrawIdx): 2, sizeof(ImDrawVert): 20
define: __cplusplus=199711
define: _WIN32
define: _WIN64
define: _MSC_VER=1944
define: _MSVC_LANG=201402
define: IMGUI_HAS_VIEWPORT
define: IMGUI_HAS_DOCK
--------------------------------

io.BackendPlatformName: imgui_impl_glfw (3400)
io.BackendRendererName: imgui_impl_opengl3
io.ConfigFlags: 0x00000483
 NavEnableKeyboard
 NavEnableGamepad
 DockingEnable
 ViewportsEnable
io.ConfigDpiScaleFonts
io.ConfigDpiScaleViewports
io.ConfigViewportsNoDecoration
io.ConfigViewportsNoDefaultParent
io.ConfigNavCaptureKeyboard
io.ConfigInputTextCursorBlink
io.ConfigWindowsResizeFromEdges
io.ConfigMemoryCompactTimer = 60.0
io.BackendFlags: 0x00001C16
 HasMouseCursors
 HasSetMousePos
 PlatformHasViewports
 HasMouseHoveredViewport
 RendererHasTextures
 RendererHasViewports
--------------------------------

io.Fonts: 1 fonts, Flags: 0x00000000, TexSize: 512,128
io.Fonts->FontLoaderName: stb_truetype
io.DisplaySize: 1600.00,1000.00
io.DisplayFramebufferScale: 1.00,1.00
--------------------------------

style.WindowPadding: 10.00,10.00
style.WindowBorderSize: 1.00
style.FramePadding: 5.00,3.00
style.FrameRounding: 0.00
style.FrameBorderSize: 0.00
style.ItemSpacing: 10.00,5.00
style.ItemInnerSpacing: 5.00,5.00

Details:

My Issue/Question:

I'm developing a GUI application with ImGui that includes docking support, allowing ImGui windows to be undocked from the main viewport.

The issue I'm facing is the following: when I run the official ImGui example with OpenGL3 and GLFW, everything works correctly - the scaling is proper and the interface looks sharp. However, when I integrate the exact same example code into my project, the interface appears blurry and not as crisp as it should be.

I've already compared the backend files using a diff checker to look for differences between the example and my implementation, but I haven't found any. What other factors could be causing this difference in visual quality? What might be affecting the rendering to make it appear blurry in my project?

Screenshots/Video:

Example one (sharp looking):

My project:

Minimal, Complete and Verifiable Example code:

Same code as in the example I said before

[ocornut]

What does ImGui_ImplGlfw_GetContentScaleForWindow() in each project ?
What’s the GLFW version compiled in each project? (It is displayed in the about box)

[ExoticGamerrrYT]

What does ImGui_ImplGlfw_GetContentScaleForWindow() do in each project?

I might not fully understand your question, but as far as I can tell, ImGui_ImplGlfw_GetContentScaleForWindow() isn’t called anywhere in the main.cpp files. It’s only used internally within the backend files (imgui_impl_glfw.cpp and imgui_impl_glfw.h), which are identical in both projects.

For reference, here’s the function definition:

// - On Windows the process needs to be marked DPI-aware!! SDL2 doesn't do it by default. You can call ::SetProcessDPIAware() or call ImGui_ImplWin32_EnableDpiAwareness() from Win32 backend.
// - Apple platforms use FramebufferScale so we always return 1.0f.
// - Some accessibility applications are declaring virtual monitors with a DPI of 0.0f, see #7902. We preserve this value for caller to handle.
float ImGui_ImplGlfw_GetContentScaleForWindow(GLFWwindow* window)
{
#if GLFW_HAS_X11_OR_WAYLAND
    if (ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData(window))
        if (bd->IsWayland)
            return 1.0f;
#endif
#if GLFW_HAS_PER_MONITOR_DPI && !(defined(__APPLE__) || defined(__EMSCRIPTEN__) || defined(__ANDROID__))
    float x_scale, y_scale;
    glfwGetWindowContentScale(window, &x_scale, &y_scale);
    return x_scale;
#else
    IM_UNUSED(window);
    return 1.0f;
#endif
}

---

What’s the GLFW version compiled in each project?
(It is displayed in the About box)

In the About box, I see the following line:

io.BackendPlatformName: imgui_impl_glfw (3200)

So I believe that corresponds to GLFW 3.2.0, correct?

That’s from the example project, which appears sharp.
In my own project, however, it shows:

io.BackendPlatformName: imgui_impl_glfw (3400)

So that one seems to be using GLFW 3.4.0.

---

I just downloaded the precompiled GLFW binaries for Windows x64, rebuilt my project, and now it works - it looks as sharp as the example.
However, I used the libraries built for Visual Studio 2015. Could that cause any future problems, since I’m using Visual Studio 2022?

Also, I’m curious - why does this happen, and which Visual Studio version are the libraries in the ImGui example built with (2012, 2013, etc.)?

[ocornut]

I might not fully understand your question, but as far as I can tell, ImGui_ImplGlfw_GetContentScaleForWindow() isn’t called anywhere in the main.cpp files.

It doesn't matter. The examples are ImGui_ImplGlfw_GetContentScaleForMonitor() which is equivalent for monitor.
Call the functions and see the results and check how your scale settings are configuring in Windows's Display Settings.
If your display settings scale are set to e.g. 150% you should get 1.5f from those functions in a DPI-enabled application, and 1.0f in a non-DPI enabled application where the OS will perform scalebuffer scaling.

The problem has nothing to do AFAIK with the Visual Studio version, that does not make a difference.

In Windows, DPI awareness needs to be declared on a per process basis, either by code or using a manifest.
My understanding is that GLFW may be doing it automatically in new version, but your report suggest the opposite, that old version would do it but not new version.
Windows also allows users to store overrides and sometimes heuristically alter them when it seems to detect some patterns, which can make things more confusing.

[ExoticGamerrrYT]

Thanks for the clarification! That makes sense.
I’ll try calling both ImGui_ImplGlfw_GetContentScaleForMonitor() and glfwGetWindowContentScale() in each project to compare their values and check whether my application is actually DPI-aware.

Just to confirm — if my project returns 1.0f while the example returns something like 1.25f (since my Windows display scale is 125%), that would mean my executable isn’t marked as DPI-aware, right?

Also, regarding DPI awareness: would you recommend explicitly calling ImGui_ImplWin32_EnableDpiAwareness() even when using the GLFW backend, or should I instead set DPI awareness through the manifest or SetProcessDpiAwarenessContext() before initializing GLFW?

By the way, I rebuilt my project using the precompiled GLFW binaries for Visual Studio 2015, even though I’m compiling my code with Visual Studio 2022. Everything works fine and looks sharp now — but could that mismatch between library and compiler versions cause any potential issues in the future?

Thanks again for your time and detailed explanation!

[ExoticGamerrrYT]

I’ve tested this further and here’s what I found:

• With GLFW 3.4 and Windows display scaling set above 100%, the ImGui interface appears blurry, even without touching any DPI-related settings.
• With GLFW 3.2 and the same increased scaling, the interface looks sharp and crisp.
• In GLFW 3.4, I’ve also called the functions you mentioned (ImGui_ImplGlfw_GetContentScaleForMonitor() and glfwGetWindowContentScale()), and they correctly detect my scale and adjust the font sizes and viewport scaling accordingly — but the rendering still looks blurry.

It seems that GLFW 3.2 might have been more “permissive,” allowing ImGui to handle DPI scaling in a way that produced sharp rendering without additional configuration. GLFW 3.4, on the other hand, seems stricter and is not producing the same crisp result despite detecting the correct scale.

If this is indeed the case, it might be worth clarifying somewhere in the documentation or release notes that GLFW 3.4 can behave differently regarding DPI scaling and may require additional setup to achieve sharp rendering.

Images:

This one is GLFW 3.4, and the scale info but is blurry

This one is GLFW 3.2 and the scale info but is NOT blurry

[ExoticGamerrrYT]

Hello, I kept doing tests and now I see this. With GLFW 3.4 if you run the example and your computer has more than 100% scale, for example 125% in my case, it looks blurry, BUT for some reason if I comment/remove this line:

style.FontScaleDpi = main_scale;

It looks sharp again even with GLFW 3.4.

Also, the reason of why with GLFW 3.2 looks sharp too is because of this line:

float main_scale = ImGui_ImplGlfw_GetContentScaleForMonitor(glfwGetPrimaryMonitor());

And if we go to the source of ImGui_ImplGlfw_GetContentScaleForMonitor() we can se this:

float ImGui_ImplGlfw_GetContentScaleForMonitor(GLFWmonitor* monitor)
{
#if GLFW_HAS_X11_OR_WAYLAND
    if (ImGui_ImplGlfw_IsWayland()) // We can't access our bd->IsWayland cache for a monitor.
        return 1.0f;
#endif
#if GLFW_HAS_PER_MONITOR_DPI && !(defined(__APPLE__) || defined(__EMSCRIPTEN__) || defined(__ANDROID__))
    float x_scale, y_scale;
    glfwGetMonitorContentScale(monitor, &x_scale, &y_scale);
    return x_scale;
#else
    IM_UNUSED(monitor);
    return 1.0f;
#endif
}

If GLFW 3.2 is used it will return 1.0f, the reason of why it looks sharp, and if GLFW 3.4 (and >=3.3 I think) is used it will execute this:

#if GLFW_HAS_PER_MONITOR_DPI && !(defined(__APPLE__) || defined(__EMSCRIPTEN__) || defined(__ANDROID__))
    float x_scale, y_scale;
    glfwGetMonitorContentScale(monitor, &x_scale, &y_scale);
    return x_scale;

And what that returns makes it blurry.

---

To sum up, if we are using GLFW 3.2 the example will look sharp at any scale, and if we are using GLFW 3.4 we have to comment/remove this line:

style.FontScaleDpi = main_scale; and this one does nothing I think so we can delete it too style.ScaleAllSizes(main_scale); also the main_scale variable is used in the window creation and I think we can remove it too, so it looks like this:

//float main_scale = ImGui_ImplGlfw_GetContentScaleForMonitor(glfwGetPrimaryMonitor()); // Valid on GLFW 3.3+ only
//GLFWwindow *window = glfwCreateWindow((int)(1280 * main_scale), (int)(800 * main_scale),
//                                      "Dear ImGui GLFW+OpenGL3 example", nullptr, nullptr);
GLFWwindow *window = glfwCreateWindow(1280, 800, "Dear ImGui GLFW+OpenGL3 example", nullptr, nullptr);

And the code will look like this:

// Dear ImGui: standalone example application for GLFW + OpenGL 3, using programmable pipeline
// (GLFW is a cross-platform general purpose library for handling windows, inputs, OpenGL/Vulkan/Metal graphics context
// creation, etc.)

// Learn about Dear ImGui:
// - FAQ                  https://dearimgui.com/faq
// - Getting Started      https://dearimgui.com/getting-started
// - Documentation        https://dearimgui.com/docs (same as your local docs/ folder).
// - Introduction, links and more at the top of imgui.cpp

#include "imgui/imgui.h"
#include "imgui/imgui_impl_glfw.h"
#include "imgui/imgui_impl_opengl3.h"
#include <stdio.h>
#define GL_SILENCE_DEPRECATION
#if defined(IMGUI_IMPL_OPENGL_ES2)
#include <GLES2/gl2.h>
#endif
#include <GLFW/glfw3.h> // Will drag system OpenGL headers

// [Win32] Our example includes a copy of glfw3.lib pre-compiled with VS2010 to maximize ease of testing and
// compatibility with old VS compilers. To link with VS2010-era libraries, VS2015+ requires linking with
// legacy_stdio_definitions.lib, which we do using this pragma. Your own project should not be affected, as you are
// likely to link with a newer binary of GLFW that is adequate for your version of Visual Studio.
#if defined(_MSC_VER) && (_MSC_VER >= 1900) && !defined(IMGUI_DISABLE_WIN32_FUNCTIONS)
#pragma comment(lib, "legacy_stdio_definitions")
#endif

// This example can also compile and run with Emscripten! See 'Makefile.emscripten' for details.
#ifdef __EMSCRIPTEN__
#include "../libs/emscripten/emscripten_mainloop_stub.h"
#endif

static void glfw_error_callback(int error, const char *description)
{
    fprintf(stderr, "GLFW Error %d: %s\n", error, description);
}

// Main code
int main(int, char **)
{
    glfwSetErrorCallback(glfw_error_callback);
    if (!glfwInit())
        return 1;

    // Decide GL+GLSL versions
#if defined(IMGUI_IMPL_OPENGL_ES2)
    // GL ES 2.0 + GLSL 100 (WebGL 1.0)
    const char *glsl_version = "#version 100";
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 2);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0);
    glfwWindowHint(GLFW_CLIENT_API, GLFW_OPENGL_ES_API);
#elif defined(IMGUI_IMPL_OPENGL_ES3)
    // GL ES 3.0 + GLSL 300 es (WebGL 2.0)
    const char *glsl_version = "#version 300 es";
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0);
    glfwWindowHint(GLFW_CLIENT_API, GLFW_OPENGL_ES_API);
#elif defined(__APPLE__)
    // GL 3.2 + GLSL 150
    const char *glsl_version = "#version 150";
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); // 3.2+ only
    glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);           // Required on Mac
#else
    // GL 3.0 + GLSL 130
    const char *glsl_version = "#version 130";
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0);
    // glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);  // 3.2+ only
    // glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);            // 3.0+ only
#endif

    // Create window with graphics context
    // float main_scale = ImGui_ImplGlfw_GetContentScaleForMonitor(glfwGetPrimaryMonitor()); // Valid on GLFW 3.3+ only
    // GLFWwindow *window = glfwCreateWindow((int)(1280 * main_scale), (int)(800 * main_scale),
    //                                      "Dear ImGui GLFW+OpenGL3 example", nullptr, nullptr);
    GLFWwindow *window = glfwCreateWindow(1280, 800, "Dear ImGui GLFW+OpenGL3 example", nullptr, nullptr);
    if (window == nullptr)
        return 1;
    glfwMakeContextCurrent(window);
    glfwSwapInterval(1); // Enable vsync

    // Setup Dear ImGui context
    IMGUI_CHECKVERSION();
    ImGui::CreateContext();
    ImGuiIO &io = ImGui::GetIO();
    (void)io;
    io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard; // Enable Keyboard Controls
    io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad;  // Enable Gamepad Controls

    // Setup Dear ImGui style
    ImGui::StyleColorsDark();
    // ImGui::StyleColorsLight();

    // Setup scaling
    ImGuiStyle &style = ImGui::GetStyle();
    // style.ScaleAllSizes(main_scale); // Bake a fixed style scale. (until we have a solution for dynamic style
    // scaling,
    //  changing this requires resetting Style + calling this again)
    // style.FontScaleDpi = main_scale; // Set initial font scale. (using io.ConfigDpiScaleFonts=true makes this
    //  unnecessary. We leave both here for documentation purpose)

    // Setup Platform/Renderer backends
    ImGui_ImplGlfw_InitForOpenGL(window, true);
#ifdef __EMSCRIPTEN__
    ImGui_ImplGlfw_InstallEmscriptenCallbacks(window, "#canvas");
#endif
    ImGui_ImplOpenGL3_Init(glsl_version);

    // Load Fonts
    // - If no fonts are loaded, dear imgui will use the default font. You can also load multiple fonts and use
    // ImGui::PushFont()/PopFont() to select them.
    // - AddFontFromFileTTF() will return the ImFont* so you can store it if you need to select the font among multiple.
    // - If the file cannot be loaded, the function will return a nullptr. Please handle those errors in your
    // application (e.g. use an assertion, or display an error and quit).
    // - Use '#define IMGUI_ENABLE_FREETYPE' in your imconfig file to use Freetype for higher quality font rendering.
    // - Read 'docs/FONTS.md' for more instructions and details. If you like the default font but want it to scale
    // better, consider using the 'ProggyVector' from the same author!
    // - Remember that in C/C++ if you want to include a backslash \ in a string literal you need to write a double
    // backslash \\ !
    // - Our Emscripten build process allows embedding fonts to be accessible at runtime from the "fonts/" folder. See
    // Makefile.emscripten for details.
    // style.FontSizeBase = 20.0f;
    // io.Fonts->AddFontDefault();
    // io.Fonts->AddFontFromFileTTF("c:\\Windows\\Fonts\\segoeui.ttf");
    // io.Fonts->AddFontFromFileTTF("../../misc/fonts/DroidSans.ttf");
    // io.Fonts->AddFontFromFileTTF("../../misc/fonts/Roboto-Medium.ttf");
    // io.Fonts->AddFontFromFileTTF("../../misc/fonts/Cousine-Regular.ttf");
    // ImFont* font = io.Fonts->AddFontFromFileTTF("c:\\Windows\\Fonts\\ArialUni.ttf");
    // IM_ASSERT(font != nullptr);

    // Our state
    bool show_demo_window = true;
    bool show_another_window = false;
    ImVec4 clear_color = ImVec4(0.45f, 0.55f, 0.60f, 1.00f);

    // Main loop
#ifdef __EMSCRIPTEN__
    // For an Emscripten build we are disabling file-system access, so let's not attempt to do a fopen() of the
    // imgui.ini file. You may manually call LoadIniSettingsFromMemory() to load settings from your own storage.
    io.IniFilename = nullptr;
    EMSCRIPTEN_MAINLOOP_BEGIN
#else
    while (!glfwWindowShouldClose(window))
#endif
    {
        // Poll and handle events (inputs, window resize, etc.)
        // You can read the io.WantCaptureMouse, io.WantCaptureKeyboard flags to tell if dear imgui wants to use your
        // inputs.
        // - When io.WantCaptureMouse is true, do not dispatch mouse input data to your main application, or
        // clear/overwrite your copy of the mouse data.
        // - When io.WantCaptureKeyboard is true, do not dispatch keyboard input data to your main application, or
        // clear/overwrite your copy of the keyboard data. Generally you may always pass all inputs to dear imgui, and
        // hide them from your application based on those two flags.
        glfwPollEvents();
        if (glfwGetWindowAttrib(window, GLFW_ICONIFIED) != 0)
        {
            ImGui_ImplGlfw_Sleep(10);
            continue;
        }

        // Start the Dear ImGui frame
        ImGui_ImplOpenGL3_NewFrame();
        ImGui_ImplGlfw_NewFrame();
        ImGui::NewFrame();

        // 1. Show the big demo window (Most of the sample code is in ImGui::ShowDemoWindow()! You can browse its code
        // to learn more about Dear ImGui!).
        if (show_demo_window)
            ImGui::ShowDemoWindow(&show_demo_window);

        // 2. Show a simple window that we create ourselves. We use a Begin/End pair to create a named window.
        {
            static float f = 0.0f;
            static int counter = 0;

            ImGui::Begin("Hello, world!"); // Create a window called "Hello, world!" and append into it.

            ImGui::Text("This is some useful text.");          // Display some text (you can use a format strings too)
            ImGui::Checkbox("Demo Window", &show_demo_window); // Edit bools storing our window open/close state
            ImGui::Checkbox("Another Window", &show_another_window);

            ImGui::SliderFloat("float", &f, 0.0f, 1.0f);             // Edit 1 float using a slider from 0.0f to 1.0f
            ImGui::ColorEdit3("clear color", (float *)&clear_color); // Edit 3 floats representing a color

            if (ImGui::Button(
                    "Button")) // Buttons return true when clicked (most widgets return true when edited/activated)
                counter++;
            ImGui::SameLine();
            ImGui::Text("counter = %d", counter);

            ImGui::Text("Application average %.3f ms/frame (%.1f FPS)", 1000.0f / io.Framerate, io.Framerate);
            ImGui::End();
        }

        // 3. Show another simple window.
        if (show_another_window)
        {
            ImGui::Begin("Another Window",
                         &show_another_window); // Pass a pointer to our bool variable (the window will have a closing
                                                // button that will clear the bool when clicked)
            ImGui::Text("Hello from another window!");
            if (ImGui::Button("Close Me"))
                show_another_window = false;
            ImGui::End();
        }

        // Rendering
        ImGui::Render();
        int display_w, display_h;
        glfwGetFramebufferSize(window, &display_w, &display_h);
        glViewport(0, 0, display_w, display_h);
        glClearColor(clear_color.x * clear_color.w, clear_color.y * clear_color.w, clear_color.z * clear_color.w,
                     clear_color.w);
        glClear(GL_COLOR_BUFFER_BIT);
        ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());

        glfwSwapBuffers(window);
    }
#ifdef __EMSCRIPTEN__
    EMSCRIPTEN_MAINLOOP_END;
#endif

    // Cleanup
    ImGui_ImplOpenGL3_Shutdown();
    ImGui_ImplGlfw_Shutdown();
    ImGui::DestroyContext();

    glfwDestroyWindow(window);
    glfwTerminate();

    return 0;
}

[pthom]

The difference between glfw 3.4 and 3.2 is that glfw 3.4 can correctly detect the monitor scale.

This is used (under windows) to change the initial window size (on your screenshot, we can see that it changed), and to change the font scale.

This is needed, because fonts and windows may appear way too small under windows when the scale is 200% for example.

In your case, you are using a non integer scaling factor (125%). With glfw3.4, the window and font size is correctly resized to 125%. In my understanding, recommended scaling factor are integers (i.e. multiple of 100%).

This may be a reason for the blur your see, especially since the default font does not scale smoothly.

From https://github.com/ocornut/imgui/blob/master/docs/FONTS.md:

The code in imgui.cpp embeds a copy of ProggyClean.ttf (by Tristan Grimmer), a 13 pixels high, pixel-perfect font used by default. We embed it in the source code so you can use Dear ImGui without any file system access. ProggyClean does not scale smoothly, therefore it is recommended that you load your own file when using Dear ImGui in an application aiming to look nice and wanting to support multiple resolutions.

[ExoticGamerrrYT]

@pthom Aaahhh, that makes sense, probably because of being 125% and font family also, i remember using Arial once and it looked nice. Thx very much mate!!

[ExoticGamerrrYT]

@pthom I can confirm that by changing the font ( in this case to segoeui) it works, the scaling is applied correctly.

Code:

#include <imgui/imgui.h>
#include <imgui/imgui_impl_opengl3.h>
#include <imgui/imgui_impl_glfw.h>
#include <GLFW/glfw3.h>
#include <stdio.h>
#include <Windows.h>

#if defined(_MSC_VER) && (_MSC_VER >= 1900) && !defined(IMGUI_DISABLE_WIN32_FUNCTIONS)
#pragma comment(lib, "legacy_stdio_definitions")
#endif

static void glfw_error_callback(int error, const char *description)
{
    fprintf(stderr, "GLFW Error %d: %s\n", error, description);
}

// Main code
int main(int, char **)
{
    // SetProcessDpiAwarenessContext(DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2); still blurry
    // SetProcessDPIAware(); // Blurry too
    glfwSetErrorCallback(glfw_error_callback);
    if (!glfwInit())
        return 1;

    // Windows OpenGL setup
    const char *glsl_version = "#version 130";
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0);
    glfwWindowHint(GLFW_VISIBLE, GLFW_FALSE);

    float main_scale = ImGui_ImplGlfw_GetContentScaleForMonitor(glfwGetPrimaryMonitor());
    GLFWwindow *window = glfwCreateWindow(1, 1, "", nullptr, nullptr);
    if (window == nullptr)
        return 1;
    glfwMakeContextCurrent(window);
    glfwSwapInterval(1);

    IMGUI_CHECKVERSION();
    ImGui::CreateContext();
    ImGuiIO &io = ImGui::GetIO();
    (void)io;

    io.IniFilename = nullptr;
    io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard; // Enable Keyboard Controls
    io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad;  // Enable Gamepad Controls
    io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable;
    io.Fonts->AddFontFromFileTTF("C:\\Windows\\Fonts\\segoeui.ttf", 18.0f);

    ImGui::StyleColorsDark(); // Keep original ImGui styling
    ImGuiStyle &style = ImGui::GetStyle();
    style.ScaleAllSizes(main_scale);
    style.FontScaleDpi = main_scale;

    ImGui_ImplGlfw_InitForOpenGL(window, true);
    ImGui_ImplOpenGL3_Init(glsl_version);

    while (!glfwWindowShouldClose(window))
    {
        glfwPollEvents();

        ImGui_ImplOpenGL3_NewFrame();
        ImGui_ImplGlfw_NewFrame();
        ImGui::NewFrame();

        ImGui::ShowAboutWindow();

        ImGui::Begin("Hello Window");

        ImGui::Text("Hello, World!");
        ImGui::Text("This is an independent ImGui window");

        if (ImGui::Button("Exit"))
        {
            glfwSetWindowShouldClose(window, true);
        }

        ImGui::End();

        ImGui::Render();
        int display_w, display_h;
        glfwGetFramebufferSize(window, &display_w, &display_h);
        glViewport(0, 0, display_w, display_h);
        glClearColor(0.45f, 0.55f, 0.60f, 1.00f);
        glClear(GL_COLOR_BUFFER_BIT);
        ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());

        if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
        {
            GLFWwindow *backup_current_context = glfwGetCurrentContext();
            ImGui::UpdatePlatformWindows();
            ImGui::RenderPlatformWindowsDefault();
            glfwMakeContextCurrent(backup_current_context);
        }

        glfwSwapBuffers(window);
    }

    ImGui_ImplOpenGL3_Shutdown();
    ImGui_ImplGlfw_Shutdown();
    ImGui::DestroyContext();

    glfwDestroyWindow(window);
    glfwTerminate();

    return 0;
}

What should I do with SetProcessDpiAwarenessContext(DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2); and SetProcessDPIAware(); ?