# glfwInit() segmentation fault

**URL:** <https://discourse.glfw.org/t/glfwinit-segmentation-fault/2181>\
**Category:** support\
**Created:** [October 19, 2022, 11:32pm UTC](https://discourse.glfw.org/t/glfwinit-segmentation-fault/2181 "2022-10-19T23:32:47Z")\
**Posts on this page:** 4\
**Page:** 1

<div class="post-metadata">

**Author:** ![prusso](https://yyz1.discourse-cdn.com/flex035/user_avatar/discourse.glfw.org/prusso/32/719_2.png) [@prusso](https://discourse.glfw.org/u/prusso)\
**Post date:** [October 19, 2022, 11:32pm UTC](https://discourse.glfw.org/t/glfwinit-segmentation-fault/2181/1 "2022-10-19T23:32:47Z")

</div>

Ubuntu 22.04.1 LTS:

```auto
#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?

---

<div class="post-metadata">

**Author:** ![dougbinks](https://yyz1.discourse-cdn.com/flex035/user_avatar/discourse.glfw.org/dougbinks/32/39_2.png) [@dougbinks](https://discourse.glfw.org/u/dougbinks)\
**Post date:** [October 20, 2022, 9:37am UTC](https://discourse.glfw.org/t/glfwinit-segmentation-fault/2181/2 "2022-10-20T09:37:41Z")

</div>

Welcome to the GLFW forum.

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

> [@prusso](#):
>
> I have a glfwInit() segmentation fault occurring when the program is run.

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](https://www.glfw.org/documentation.html) 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](https://github.com/juliettef/GLFW-CMake-starter).

---

<div class="post-metadata">

**Author:** ![prusso](https://yyz1.discourse-cdn.com/flex035/user_avatar/discourse.glfw.org/prusso/32/719_2.png) [@prusso](https://discourse.glfw.org/u/prusso)\
**Post date:** [October 21, 2022, 10:48pm UTC](https://discourse.glfw.org/t/glfwinit-segmentation-fault/2181/3 "2022-10-21T22:48:42Z")

</div>

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

```auto
#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)

```auto

```

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.

---

<div class="post-metadata">

**Author:** ![prusso](https://yyz1.discourse-cdn.com/flex035/user_avatar/discourse.glfw.org/prusso/32/719_2.png) [@prusso](https://discourse.glfw.org/u/prusso)\
**Post date:** [October 21, 2022, 11:13pm UTC](https://discourse.glfw.org/t/glfwinit-segmentation-fault/2181/4 "2022-10-21T23:13:05Z")

</div>

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

```auto
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.