glfwInit() segmentation fault

Ubuntu 22.04.1 LTS:

#include <glad/glad.h>
#include <GLFW/glfw3.h>


int main()
{
    glfwInit();
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 6);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
    //glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
  
    return 0;
}

Starting build…
/usr/bin/g++ -fdiagnostics-color=always -g /home/prusso/glfw3-helloworld/main.cpp src/glad.c -o /home/prusso/glfw3-helloworld/main -lglfw3 -lGL -lGLEW -lX11 -lXrandr -lXxf86vm -lXi
Build finished successfully.

I have a glfwInit() segmentation fault occurring when the program is run. Does anyone know if there is a way to get the segmentation fault to go away on Ubuntu 22.04.1 LTS?

Welcome to the GLFW forum.

I am running Ubuntu 22.04.1 LTS and have not had this issue with my GLFW code.

Do you have the actual output generated when the program is run, and have you tried running with a debugger such as gdb to identify where it is segfaulting? The code shown isn’t handling errors from glfwInit(), isn’t calling glfwTerminate() on exit, and exits before opening a window (though I assume that is just to show a minimal amount of code).

I would try the example code in the documentation and if that fails then try building GLFW from source and running the examples and tests to check your system. If you want to try using cmake to create your own programs then check out this simple cross platform GLFW cmake starter.

The following code does work for me in VS Code when using CMake:

#define GLFW_TRUE 1
#define GLFW_INCLUDE_NONE 1

#include "include/glad/glad.h"
#include <GLFW/glfw3.h>
#include "linmath.h"
#include <stdlib.h>
#include <stddef.h>
#include <stdio.h>


typedef struct Vertex
{
  vec2 pos;
  vec3 col;
} Vertex;

static const Vertex vertices[3] =
    {
        {{-0.6f, -0.4f}, {1.f, 0.f, 0.f}},
        {{0.6f, -0.4f}, {0.f, 1.f, 0.f}},
        {{0.f, 0.6f}, {0.f, 0.f, 1.f}}};

static const char *vertex_shader_text =
    "#version 330\n"
    "uniform mat4 MVP;\n"
    "in vec3 vCol;\n"
    "in vec2 vPos;\n"
    "out vec3 color;\n"
    "void main()\n"
    "{\n"
    "    gl_Position = MVP * vec4(vPos, 0.0, 1.0);\n"
    "    color = vCol;\n"
    "}\n";

static const char *fragment_shader_text =
    "#version 330\n"
    "in vec3 color;\n"
    "out vec4 fragment;\n"
    "void main()\n"
    "{\n"
    "    fragment = vec4(color, 1.0);\n"
    "}\n";

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

static void key_callback(GLFWwindow *window, int key, int scancode, int action, int mods)
{
  if (key == GLFW_KEY_ESCAPE && action == GLFW_PRESS)
    glfwSetWindowShouldClose(window, GLFW_TRUE);
}

int main(void)
{
  glfwSetErrorCallback(error_callback);

  if (!glfwInit())
    exit(EXIT_FAILURE);

  glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
  glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
  glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

  GLFWwindow *window = glfwCreateWindow(640, 480, "OpenGL Triangle", NULL, NULL);
  if (!window)
  {
    glfwTerminate();
    exit(EXIT_FAILURE);
  }

  glfwSetKeyCallback(window, key_callback);

  glfwMakeContextCurrent(window);
  gladLoadGLLoader((GLADloadproc)glfwGetProcAddress);
  glfwSwapInterval(1);

  // NOTE: OpenGL error checks have been omitted for brevity

  GLuint vertex_buffer;
  glGenBuffers(1, &vertex_buffer);
  glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer);
  glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

  const GLuint vertex_shader = glCreateShader(GL_VERTEX_SHADER);
  glShaderSource(vertex_shader, 1, &vertex_shader_text, NULL);
  glCompileShader(vertex_shader);

  const GLuint fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
  glShaderSource(fragment_shader, 1, &fragment_shader_text, NULL);
  glCompileShader(fragment_shader);

  const GLuint program = glCreateProgram();
  glAttachShader(program, vertex_shader);
  glAttachShader(program, fragment_shader);
  glLinkProgram(program);

  const GLint mvp_location = glGetUniformLocation(program, "MVP");
  const GLint vpos_location = glGetAttribLocation(program, "vPos");
  const GLint vcol_location = glGetAttribLocation(program, "vCol");

  GLuint vertex_array;
  glGenVertexArrays(1, &vertex_array);
  glBindVertexArray(vertex_array);
  glEnableVertexAttribArray(vpos_location);
  glVertexAttribPointer(vpos_location, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void *)offsetof(Vertex, pos));
  glEnableVertexAttribArray(vcol_location);
  glVertexAttribPointer(vcol_location, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void *)offsetof(Vertex, col));

  while (!glfwWindowShouldClose(window))
  {
    int width, height;
    glfwGetFramebufferSize(window, &width, &height);
    const float ratio = width / (float)height;

    glViewport(0, 0, width, height);
    glClear(GL_COLOR_BUFFER_BIT);

    mat4x4 m, p, mvp;
    mat4x4_identity(m);
    mat4x4_rotate_Z(m, m, (float)glfwGetTime());
    mat4x4_ortho(p, -ratio, ratio, -1.f, 1.f, 1.f, -1.f);
    mat4x4_mul(mvp, p, m);

    glUseProgram(program);
    glUniformMatrix4fv(mvp_location, 1, GL_FALSE, (const GLfloat *)&mvp);
    glBindVertexArray(vertex_array);
    glDrawArrays(GL_TRIANGLES, 0, 3);

    glfwSwapBuffers(window);
    glfwPollEvents();
  }

  glfwDestroyWindow(window);

  glfwTerminate();
  exit(EXIT_SUCCESS);
}


With this CMakeLists.txt:

cmake_minimum_required(VERSION 3.0.0)

set(OpenGL_GL_PREFERENCE GLVND)

project(glfw3-glad VERSION 0.1.0)

include(CTest)

enable_testing()

add_executable(glfw3-glad main.cpp src/glad.c)

find_package(glfw3 3.3 REQUIRED)

target_link_libraries(glfw3-glad glfw)

find_package(OpenGL REQUIRED)

target_link_libraries(glfw3-glad OpenGL::GL)

set(CPACK_PROJECT_NAME ${PROJECT_NAME})

set(CPACK_PROJECT_VERSION ${PROJECT_VERSION})

include(CPack)

Anybody know how to set this thing up to compile with g++ as far as linking with libraries and also to glad? There is a glad.c is that a required file at compile time I would assume so but didn’t see any documentation yet to that effect. Just a g++ command line how to compile this example would really help me a lot. I don’t always want to use CMake all the time.

So I did get a binary to compile with the g++ I had posted with the glad example:

g++ -fdiagnostics-color=always -g /home/prusso/glfw3-helloworld/main.cpp src/glad.c -o main -lglfw3 -lGL -lX11 -lXrandr -lXxf86vm -lXi

It generated a working binary that I can start up and look at once that all of the nvidea drivers were installed on my Ubuntu from the software updater it did work.