diff --git a/glfw/build.zig b/glfw/build.zig
index cfa01a2..039357d 100644
--- a/glfw/build.zig
+++ b/glfw/build.zig
@@ -320,7 +320,7 @@ fn confirmAppleSDKAgreement(allocator: *std.mem.Allocator) !bool {
     if (try stdin.readUntilDelimiterOrEof(buf[0..], '\n')) |user_input| {
         try stdout.print("\n", .{});
         var in = user_input;
-        if (in[in.len - 1] == '\r') in = in[0 .. in.len - 1];
+        if (in.len > 0 and in[in.len - 1] == '\r') in = in[0 .. in.len - 1];
         return std.mem.eql(u8, in, "y") or std.mem.eql(u8, in, "Y") or std.mem.eql(u8, in, "yes") or std.mem.eql(u8, in, "");
     } else {
         return false;
diff --git a/glfw/libglfw3.a b/glfw/libglfw3.a
new file mode 100644
index 0000000..9cdcc3a
Binary files /dev/null and b/glfw/libglfw3.a differ
diff --git a/glfw/src/TODO b/glfw/src/TODO
new file mode 100644
index 0000000..6810476
--- /dev/null
+++ b/glfw/src/TODO
@@ -0,0 +1,2719 @@
+
+GLFW_INCLUDE_VULKAN
+#if defined(GLFW_INCLUDE_ES1)
+ #if defined(GLFW_INCLUDE_GLEXT)
+#elif defined(GLFW_INCLUDE_ES2)
+#elif defined(GLFW_INCLUDE_ES3)
+#elif defined(GLFW_INCLUDE_ES31)
+#elif defined(GLFW_INCLUDE_ES32)
+#elif defined(GLFW_INCLUDE_GLCOREARB)
+  #if defined(GLFW_INCLUDE_GLU)
+
+zig build test -Dtarget=x86_64-windows --verbose 2>&1|less
+
+/// One.
+///
+/// This is only semantic sugar for the number 1. You can instead use `1` or
+/// `true` or `_True` or `GL_TRUE` or `VK_TRUE` or anything else that is equal
+/// to one.
+///
+/// @ingroup init
+#define GLFW_TRUE                   1
+/// Zero.
+///
+/// This is only semantic sugar for the number 0. You can instead use `0` or
+/// `false` or `_False` or `GL_FALSE` or `VK_FALSE` or anything else that is
+/// equal to zero.
+///
+/// @ingroup init
+#define GLFW_FALSE                  0
+
+
+/*************************************************************************
+///GLFW API types
+ *************************************************************************/
+
+/// Client API function pointer type.
+///
+/// Generic function pointer used for returning client API function pointers
+/// without forcing a cast from a regular pointer.
+///
+/// see also: context_glext, glfwGetProcAddress
+///
+///
+/// @ingroup context
+typedef void (*GLFWglproc)(void);
+
+/// Vulkan API function pointer type.
+///
+/// Generic function pointer used for returning Vulkan API function pointers
+/// without forcing a cast from a regular pointer.
+///
+/// see also: vulkan_proc, glfwGetInstanceProcAddress
+///
+///
+/// @ingroup vulkan
+typedef void (*GLFWvkproc)(void);
+
+/// Opaque cursor object.
+///
+/// Opaque cursor object.
+///
+/// see also: cursor_object
+///
+///
+/// @ingroup input
+typedef struct GLFWcursor GLFWcursor;
+
+/// The function pointer type for error callbacks.
+///
+/// This is the function pointer type for error callbacks. An error callback
+/// function has the following signature:
+/// @code
+/// void callback_name(int error_code, const char* description)
+/// @endcode
+///
+/// @param[in] error_code An error code. Future releases may add
+/// more error codes.
+/// @param[in] description A UTF-8 encoded string describing the error.
+///
+/// @pointer_lifetime The error description string is valid until the callback
+/// function returns.
+///
+/// see also: error_handling, glfwSetErrorCallback
+///
+///
+/// @ingroup init
+typedef void (* GLFWerrorfun)(int,const char*);
+
+/// The function pointer type for window position callbacks.
+///
+/// This is the function pointer type for window position callbacks. A window
+/// position callback function has the following signature:
+/// @code
+/// void callback_name(GLFWwindow* window, int xpos, int ypos)
+/// @endcode
+///
+/// @param[in] window The window that was moved.
+/// @param[in] xpos The new x-coordinate, in screen coordinates, of the
+/// upper-left corner of the content area of the window.
+/// @param[in] ypos The new y-coordinate, in screen coordinates, of the
+/// upper-left corner of the content area of the window.
+///
+/// see also: window_pos, glfwSetWindowPosCallback
+///
+typedef void (* GLFWwindowposfun)(GLFWwindow*,int,int);
+
+/// The function pointer type for window size callbacks.
+///
+/// This is the function pointer type for window size callbacks. A window size
+/// callback function has the following signature:
+/// @code
+/// void callback_name(GLFWwindow* window, int width, int height)
+/// @endcode
+///
+/// @param[in] window The window that was resized.
+/// @param[in] width The new width, in screen coordinates, of the window.
+/// @param[in] height The new height, in screen coordinates, of the window.
+///
+/// see also: window_size, glfw.Window.setSizeCallback
+///
+/// @glfw3 Added window handle parameter.
+typedef void (* GLFWwindowsizefun)(GLFWwindow*,int,int);
+
+/// The function pointer type for window close callbacks.
+///
+/// This is the function pointer type for window close callbacks. A window
+/// close callback function has the following signature:
+/// @code
+/// void function_name(GLFWwindow* window)
+/// @endcode
+///
+/// @param[in] window The window that the user attempted to close.
+///
+/// see also: window_close, glfw.Window.setCloseCallback
+///
+/// @glfw3 Added window handle parameter.
+typedef void (* GLFWwindowclosefun)(GLFWwindow*);
+
+/// The function pointer type for window content refresh callbacks.
+///
+/// This is the function pointer type for window content refresh callbacks.
+/// A window content refresh callback function has the following signature:
+/// @code
+/// void function_name(GLFWwindow* window);
+/// @endcode
+///
+/// @param[in] window The window whose content needs to be refreshed.
+///
+/// see also: window_refresh, glfw.Window.setRefreshCallback
+///
+/// @glfw3 Added window handle parameter.
+typedef void (* GLFWwindowrefreshfun)(GLFWwindow*);
+
+/// The function pointer type for window focus callbacks.
+///
+/// This is the function pointer type for window focus callbacks. A window
+/// focus callback function has the following signature:
+/// @code
+/// void function_name(GLFWwindow* window, int focused)
+/// @endcode
+///
+/// @param[in] window The window that gained or lost input focus.
+/// @param[in] focused `GLFW_TRUE` if the window was given input focus, or
+/// `GLFW_FALSE` if it lost it.
+///
+/// see also: window_focus, glfw.Window.setFocusCallback
+///
+typedef void (* GLFWwindowfocusfun)(GLFWwindow*,int);
+
+/// The function pointer type for window iconify callbacks.
+///
+/// This is the function pointer type for window iconify callbacks. A window
+/// iconify callback function has the following signature:
+/// @code
+/// void function_name(GLFWwindow* window, int iconified)
+/// @endcode
+///
+/// @param[in] window The window that was iconified or restored.
+/// @param[in] iconified `GLFW_TRUE` if the window was iconified, or
+/// `GLFW_FALSE` if it was restored.
+///
+/// see also: window_iconify, glfw.Window.setIconifyCallback
+///
+typedef void (* GLFWwindowiconifyfun)(GLFWwindow*,int);
+
+/// The function pointer type for window maximize callbacks.
+///
+/// This is the function pointer type for window maximize callbacks. A window
+/// maximize callback function has the following signature:
+/// @code
+/// void function_name(GLFWwindow* window, int maximized)
+/// @endcode
+///
+/// @param[in] window The window that was maximized or restored.
+/// @param[in] maximized `GLFW_TRUE` if the window was maximized, or
+/// `GLFW_FALSE` if it was restored.
+///
+/// see also: window_maximize, /// see also: glfw.Window.setMaximizeCallback
+///
+typedef void (* GLFWwindowmaximizefun)(GLFWwindow*,int);
+
+/// The function pointer type for framebuffer size callbacks.
+///
+/// This is the function pointer type for framebuffer size callbacks.
+/// A framebuffer size callback function has the following signature:
+/// @code
+/// void function_name(GLFWwindow* window, int width, int height)
+/// @endcode
+///
+/// @param[in] window The window whose framebuffer was resized.
+/// @param[in] width The new width, in pixels, of the framebuffer.
+/// @param[in] height The new height, in pixels, of the framebuffer.
+///
+/// see also: window_fbsize, glfw.Window.setFramebufferSizeCallback
+///
+typedef void (* GLFWframebuffersizefun)(GLFWwindow*,int,int);
+
+/// The function pointer type for window content scale callbacks.
+///
+/// This is the function pointer type for window content scale callbacks.
+/// A window content scale callback function has the following signature:
+/// @code
+/// void function_name(GLFWwindow* window, float xscale, float yscale)
+/// @endcode
+///
+/// @param[in] window The window whose content scale changed.
+/// @param[in] xscale The new x-axis content scale of the window.
+/// @param[in] yscale The new y-axis content scale of the window.
+///
+/// see also: window_scale, glfwSetWindowContentScaleCallback
+///
+typedef void (* GLFWwindowcontentscalefun)(GLFWwindow*,float,float);
+
+/// The function pointer type for mouse button callbacks.
+///
+/// This is the function pointer type for mouse button callback functions.
+/// A mouse button callback function has the following signature:
+/// @code
+/// void function_name(GLFWwindow* window, int button, int action, int mods)
+/// @endcode
+///
+/// @param[in] window The window that received the event.
+/// @param[in] button The mouse button that was pressed or
+/// released.
+/// @param[in] action One of `GLFW_PRESS` or `GLFW_RELEASE`. Future releases
+/// may add more actions.
+/// @param[in] mods Bit field describing which [modifier keys](@ref mods) were
+/// held down.
+///
+/// see also: input_mouse_button, glfwSetMouseButtonCallback
+///
+/// @glfw3 Added window handle and modifier mask parameters.
+///
+/// @ingroup input
+typedef void (* GLFWmousebuttonfun)(GLFWwindow*,int,int,int);
+
+/// The function pointer type for cursor position callbacks.
+///
+/// This is the function pointer type for cursor position callbacks. A cursor
+/// position callback function has the following signature:
+/// @code
+/// void function_name(GLFWwindow* window, double xpos, double ypos);
+/// @endcode
+///
+/// @param[in] window The window that received the event.
+/// @param[in] xpos The new cursor x-coordinate, relative to the left edge of
+/// the content area.
+/// @param[in] ypos The new cursor y-coordinate, relative to the top edge of the
+/// content area.
+///
+/// see also: cursor_pos, glfw.setCursorPosCallback
+/// Replaces `GLFWmouseposfun`.
+///
+/// @ingroup input
+typedef void (* GLFWcursorposfun)(GLFWwindow*,double,double);
+
+/// The function pointer type for cursor enter/leave callbacks.
+///
+/// This is the function pointer type for cursor enter/leave callbacks.
+/// A cursor enter/leave callback function has the following signature:
+/// @code
+/// void function_name(GLFWwindow* window, int entered)
+/// @endcode
+///
+/// @param[in] window The window that received the event.
+/// @param[in] entered `GLFW_TRUE` if the cursor entered the window's content
+/// area, or `GLFW_FALSE` if it left it.
+///
+/// see also: cursor_enter, glfwSetCursorEnterCallback
+///
+///
+/// @ingroup input
+typedef void (* GLFWcursorenterfun)(GLFWwindow*,int);
+
+/// The function pointer type for scroll callbacks.
+///
+/// This is the function pointer type for scroll callbacks. A scroll callback
+/// function has the following signature:
+/// @code
+/// void function_name(GLFWwindow* window, double xoffset, double yoffset)
+/// @endcode
+///
+/// @param[in] window The window that received the event.
+/// @param[in] xoffset The scroll offset along the x-axis.
+/// @param[in] yoffset The scroll offset along the y-axis.
+///
+/// see also: scrolling, glfwSetScrollCallback
+/// Replaces `GLFWmousewheelfun`.
+///
+/// @ingroup input
+typedef void (* GLFWscrollfun)(GLFWwindow*,double,double);
+
+/// The function pointer type for keyboard key callbacks.
+///
+/// This is the function pointer type for keyboard key callbacks. A keyboard
+/// key callback function has the following signature:
+/// @code
+/// void function_name(GLFWwindow* window, int key, int scancode, int action, int mods)
+/// @endcode
+///
+/// @param[in] window The window that received the event.
+/// @param[in] key The [keyboard key](@ref keys) that was pressed or released.
+/// @param[in] scancode The system-specific scancode of the key.
+/// @param[in] action `GLFW_PRESS`, `GLFW_RELEASE` or `GLFW_REPEAT`. Future
+/// releases may add more actions.
+/// @param[in] mods Bit field describing which [modifier keys](@ref mods) were
+/// held down.
+///
+/// see also: input_key, glfwSetKeyCallback
+///
+/// @glfw3 Added window handle, scancode and modifier mask parameters.
+///
+/// @ingroup input
+typedef void (* GLFWkeyfun)(GLFWwindow*,int,int,int,int);
+
+/// The function pointer type for Unicode character callbacks.
+///
+/// This is the function pointer type for Unicode character callbacks.
+/// A Unicode character callback function has the following signature:
+/// @code
+/// void function_name(GLFWwindow* window, unsigned int codepoint)
+/// @endcode
+///
+/// @param[in] window The window that received the event.
+/// @param[in] codepoint The Unicode code point of the character.
+///
+/// see also: input_char, glfwSetCharCallback
+///
+/// @glfw3 Added window handle parameter.
+///
+/// @ingroup input
+typedef void (* GLFWcharfun)(GLFWwindow*,unsigned int);
+
+/// The function pointer type for path drop callbacks.
+///
+/// This is the function pointer type for path drop callbacks. A path drop
+/// callback function has the following signature:
+/// @code
+/// void function_name(GLFWwindow* window, int path_count, const char* paths[])
+/// @endcode
+///
+/// @param[in] window The window that received the event.
+/// @param[in] path_count The number of dropped paths.
+/// @param[in] paths The UTF-8 encoded file and/or directory path names.
+///
+/// @pointer_lifetime The path array and its strings are valid until the
+/// callback function returns.
+///
+/// see also: path_drop, glfwSetDropCallback
+///
+///
+/// @ingroup input
+typedef void (* GLFWdropfun)(GLFWwindow*,int,const char*[]);
+
+/// The function pointer type for joystick configuration callbacks.
+///
+/// This is the function pointer type for joystick configuration callbacks.
+/// A joystick configuration callback function has the following signature:
+/// @code
+/// void function_name(int jid, int event)
+/// @endcode
+///
+/// @param[in] jid The joystick that was connected or disconnected.
+/// @param[in] event One of `GLFW_CONNECTED` or `GLFW_DISCONNECTED`. Future
+/// releases may add more events.
+///
+/// see also: joystick_event, glfwSetJoystickCallback
+///
+///
+/// @ingroup input
+typedef void (* GLFWjoystickfun)(int,int);
+
+/// Gamepad input state
+///
+/// This describes the input state of a gamepad.
+///
+/// see also: gamepad, glfwGetGamepadState
+///
+///
+/// @ingroup input
+typedef struct GLFWgamepadstate
+{
+    /*! The states of each [gamepad button](@ref gamepad_buttons), `GLFW_PRESS`
+    /// or `GLFW_RELEASE`.
+        unsigned char buttons[15];
+    /*! The states of each [gamepad axis](@ref gamepad_axes), in the range -1.0
+    /// to 1.0 inclusive.
+        float axes[6];
+} GLFWgamepadstate;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/*************************************************************************
+///GLFW API functions
+ *************************************************************************/
+
+/// Restores the specified window.
+///
+/// This function restores the specified window if it was previously iconified
+/// (minimized) or maximized. If the window is already restored, this function
+/// does nothing.
+///
+/// If the specified window is a full screen window, the resolution chosen for
+/// the window is restored on the selected monitor.
+///
+/// @param[in] window The window to restore.
+///
+/// Possible errors include glfw.Error.NotInitialized and glfw.Error.PlatformError.
+///
+/// @thread_safety This function must only be called from the main thread.
+///
+/// see also: window_iconify, glfw.Window.iconify, glfw.Window.maximize
+///
+/// @glfw3 Added window handle parameter.
+GLFWAPI void glfwRestoreWindow(GLFWwindow* window);
+
+/// Maximizes the specified window.
+///
+/// This function maximizes the specified window if it was previously not
+/// maximized. If the window is already maximized, this function does nothing.
+///
+/// If the specified window is a full screen window, this function does nothing.
+///
+/// @param[in] window The window to maximize.
+///
+/// Possible errors include glfw.Error.NotInitialized and glfw.Error.PlatformError.
+///
+/// @par Thread Safety
+/// This function may only be called from the main thread.
+///
+/// see also: window_iconify, glfw.Window.iconify, glfw.Window.restore
+GLFWAPI void glfwMaximizeWindow(GLFWwindow* window);
+
+/// Makes the specified window visible.
+///
+/// This function makes the specified window visible if it was previously
+/// hidden. If the window is already visible or is in full screen mode, this
+/// function does nothing.
+///
+/// By default, windowed mode windows are focused when shown
+/// Set the [GLFW_FOCUS_ON_SHOW](@ref GLFW_FOCUS_ON_SHOW_hint) window hint
+/// to change this behavior for all newly created windows, or change the
+/// behavior for an existing window with glfw.Window.setAttrib.
+///
+/// @param[in] window The window to make visible.
+///
+/// Possible errors include glfw.Error.NotInitialized and glfw.Error.PlatformError.
+///
+/// @thread_safety This function must only be called from the main thread.
+///
+/// see also: window_hide, glfw.Window.hide
+///
+GLFWAPI void glfwShowWindow(GLFWwindow* window);
+
+/// Hides the specified window.
+///
+/// This function hides the specified window if it was previously visible. If
+/// the window is already hidden or is in full screen mode, this function does
+/// nothing.
+///
+/// @param[in] window The window to hide.
+///
+/// Possible errors include glfw.Error.NotInitialized and glfw.Error.PlatformError.
+///
+/// @thread_safety This function must only be called from the main thread.
+///
+/// see also: window_hide, glfw.Window.show
+///
+GLFWAPI void glfwHideWindow(GLFWwindow* window);
+
+/// Brings the specified window to front and sets input focus.
+///
+/// This function brings the specified window to front and sets input focus.
+/// The window should already be visible and not iconified.
+///
+/// By default, both windowed and full screen mode windows are focused when
+/// initially created. Set the [GLFW_FOCUSED](@ref GLFW_FOCUSED_hint) to
+/// disable this behavior.
+///
+/// Also by default, windowed mode windows are focused when shown
+/// with @ref glfwShowWindow. Set the
+/// [GLFW_FOCUS_ON_SHOW](@ref GLFW_FOCUS_ON_SHOW_hint) to disable this behavior.
+///
+/// __Do not use this function__ to steal focus from other applications unless
+/// you are certain that is what the user wants. Focus stealing can be
+/// extremely disruptive.
+///
+/// For a less disruptive way of getting the user's attention, see
+/// [attention requests](@ref window_attention).
+///
+/// @param[in] window The window to give input focus.
+///
+/// Possible errors include glfw.Error.NotInitialized and glfw.Error.PlatformError.
+///
+/// wayland: It is not possible for an application to bring its windows
+/// to front, this function will always emit glfw.Error.PlatformError.
+///
+/// @thread_safety This function must only be called from the main thread.
+///
+/// see also: window_focus, window_attention
+///
+GLFWAPI void glfwFocusWindow(GLFWwindow* window);
+
+/// Requests user attention to the specified window.
+///
+/// This function requests user attention to the specified window. On
+/// platforms where this is not supported, attention is requested to the
+/// application as a whole.
+///
+/// Once the user has given attention, usually by focusing the window or
+/// application, the system will end the request automatically.
+///
+/// @param[in] window The window to request attention to.
+///
+/// Possible errors include glfw.Error.NotInitialized and glfw.Error.PlatformError.
+///
+/// macos: Attention is requested to the application as a whole, not the
+/// specific window.
+///
+/// @thread_safety This function must only be called from the main thread.
+///
+/// see also: window_attention
+///
+GLFWAPI void glfwRequestWindowAttention(GLFWwindow* window);
+
+/// Returns the monitor that the window uses for full screen mode.
+///
+/// This function returns the handle of the monitor that the specified window is
+/// in full screen on.
+///
+/// @param[in] window The window to query.
+/// @return The monitor, or null if the window is in windowed mode or an
+/// error occurred.
+///
+/// Possible errors include glfw.Error.NotInitialized.
+///
+/// @thread_safety This function must only be called from the main thread.
+///
+/// see also: window_monitor, glfw.Window.setMonitor
+///
+GLFWAPI GLFWmonitor* glfwGetWindowMonitor(GLFWwindow* window);
+
+/// Sets the mode, monitor, video mode and placement of a window.
+///
+/// This function sets the monitor that the window uses for full screen mode or,
+/// if the monitor is null, makes it windowed mode.
+///
+/// When setting a monitor, this function updates the width, height and refresh
+/// rate of the desired video mode and switches to the video mode closest to it.
+/// The window position is ignored when setting a monitor.
+///
+/// When the monitor is null, the position, width and height are used to
+/// place the window content area. The refresh rate is ignored when no monitor
+/// is specified.
+///
+/// If you only wish to update the resolution of a full screen window or the
+/// size of a windowed mode window, see @ref glfwSetWindowSize.
+///
+/// When a window transitions from full screen to windowed mode, this function
+/// restores any previous window settings such as whether it is decorated,
+/// floating, resizable, has size or aspect ratio limits, etc.
+///
+/// @param[in] window The window whose monitor, size or video mode to set.
+/// @param[in] monitor The desired monitor, or null to set windowed mode.
+/// @param[in] xpos The desired x-coordinate of the upper-left corner of the
+/// content area.
+/// @param[in] ypos The desired y-coordinate of the upper-left corner of the
+/// content area.
+/// @param[in] width The desired with, in screen coordinates, of the content
+/// area or video mode.
+/// @param[in] height The desired height, in screen coordinates, of the content
+/// area or video mode.
+/// @param[in] refreshRate The desired refresh rate, in Hz, of the video mode,
+/// or `GLFW_DONT_CARE`.
+///
+/// Possible errors include glfw.Error.NotInitialized and glfw.Error.PlatformError.
+///
+/// The OpenGL or OpenGL ES context will not be destroyed or otherwise
+/// affected by any resizing or mode switching, although you may need to update
+/// your viewport if the framebuffer size has changed.
+///
+/// wayland: The desired window position is ignored, as there is no way
+/// for an application to set this property.
+///
+/// wayland: Setting the window to full screen will not attempt to
+/// change the mode, no matter what the requested size or refresh rate.
+///
+/// @thread_safety This function must only be called from the main thread.
+///
+/// see also: window_monitor, window_full_screen, glfw.Window.getMonitor, glfw.Window.setSize
+///
+GLFWAPI void glfwSetWindowMonitor(GLFWwindow* window, GLFWmonitor* monitor, int xpos, int ypos, int width, int height, int refreshRate);
+
+/// Returns an attribute of the specified window.
+///
+/// This function returns the value of an attribute of the specified window or
+/// its OpenGL or OpenGL ES context.
+///
+/// @param[in] window The window to query.
+/// @param[in] attrib The [window attribute](@ref window_attribs) whose value to
+/// return.
+/// @return The value of the attribute, or zero if an
+/// error occurred.
+///
+/// Possible errors include glfw.Error.NotInitialized, glfw.Error.InvalidEnum and glfw.Error.PlatformError.
+///
+/// Framebuffer related hints are not window attributes. See @ref
+/// window_attribs_fb for more information.
+///
+/// Zero is a valid value for many window and context related
+/// attributes so you cannot use a return value of zero as an indication of
+/// errors. However, this function should not fail as long as it is passed
+/// valid arguments and the library has been [initialized](@ref intro_init).
+///
+/// @thread_safety This function must only be called from the main thread.
+///
+/// see also: window_attribs, glfw.Window.setAttrib
+GLFWAPI int glfwGetWindowAttrib(GLFWwindow* window, int attrib);
+
+/// Sets an attribute of the specified window.
+///
+/// This function sets the value of an attribute of the specified window.
+///
+/// The supported attributes are [GLFW_DECORATED](@ref GLFW_DECORATED_attrib),
+/// [GLFW_RESIZABLE](@ref GLFW_RESIZABLE_attrib),
+/// [GLFW_FLOATING](@ref GLFW_FLOATING_attrib),
+/// [GLFW_AUTO_ICONIFY](@ref GLFW_AUTO_ICONIFY_attrib) and
+/// [GLFW_FOCUS_ON_SHOW](@ref GLFW_FOCUS_ON_SHOW_attrib).
+///
+/// Some of these attributes are ignored for full screen windows. The new
+/// value will take effect if the window is later made windowed.
+///
+/// Some of these attributes are ignored for windowed mode windows. The new
+/// value will take effect if the window is later made full screen.
+///
+/// @param[in] window The window to set the attribute for.
+/// @param[in] attrib A supported window attribute.
+/// @param[in] value `GLFW_TRUE` or `GLFW_FALSE`.
+///
+/// Possible errors include glfw.Error.NotInitialized, glfw.Error.InvalidEnum, glfw.Error.InvalidValue and glfw.Error.PlatformError.
+///
+/// Calling glfw.Window.getAttrib will always return the latest
+/// value, even if that value is ignored by the current mode of the window.
+///
+/// @thread_safety This function must only be called from the main thread.
+///
+/// see also: window_attribs, glfw.Window.getAttrib
+///
+GLFWAPI void glfwSetWindowAttrib(GLFWwindow* window, int attrib, int value);
+
+/// Sets the user pointer of the specified window.
+///
+/// This function sets the user-defined pointer of the specified window. The
+/// current value is retained until the window is destroyed. The initial value
+/// is null.
+///
+/// @param[in] window The window whose pointer to set.
+/// @param[in] pointer The new value.
+///
+/// Possible errors include glfw.Error.NotInitialized.
+///
+/// @thread_safety This function may be called from any thread. Access is not
+/// synchronized.
+///
+/// see also: window_userptr, glfwGetWindowUserPointer
+///
+GLFWAPI void glfwSetWindowUserPointer(GLFWwindow* window, void* pointer);
+
+/// Returns the user pointer of the specified window.
+///
+/// This function returns the current value of the user-defined pointer of the
+/// specified window. The initial value is null.
+///
+/// @param[in] window The window whose pointer to return.
+///
+/// Possible errors include glfw.Error.NotInitialized.
+///
+/// @thread_safety This function may be called from any thread. Access is not
+/// synchronized.
+///
+/// see also: window_userptr, glfwSetWindowUserPointer
+///
+GLFWAPI void* glfwGetWindowUserPointer(GLFWwindow* window);
+
+/// Sets the position callback for the specified window.
+///
+/// This function sets the position callback of the specified window, which is
+/// called when the window is moved. The callback is provided with the
+/// position, in screen coordinates, of the upper-left corner of the content
+/// area of the window.
+///
+/// @param[in] window The window whose callback to set.
+/// @param[in] callback The new callback, or null to remove the currently set
+/// callback.
+/// @return The previously set callback, or null if no callback was set or the
+/// library had not been [initialized](@ref intro_init).
+///
+/// @callback_signature
+/// @code
+/// void function_name(GLFWwindow* window, int xpos, int ypos)
+/// @endcode
+/// For more information about the callback parameters, see the
+/// [function pointer type](@ref GLFWwindowposfun).
+///
+/// Possible errors include glfw.Error.NotInitialized.
+///
+/// wayland: This callback will never be called, as there is no way for
+/// an application to know its global position.
+///
+/// @thread_safety This function must only be called from the main thread.
+///
+/// see also: window_pos
+///
+GLFWAPI GLFWwindowposfun glfwSetWindowPosCallback(GLFWwindow* window, GLFWwindowposfun callback);
+
+/// Sets the size callback for the specified window.
+///
+/// This function sets the size callback of the specified window, which is
+/// called when the window is resized. The callback is provided with the size,
+/// in screen coordinates, of the content area of the window.
+///
+/// @param[in] window The window whose callback to set.
+/// @param[in] callback The new callback, or null to remove the currently set
+/// callback.
+/// @return The previously set callback, or null if no callback was set or the
+/// library had not been [initialized](@ref intro_init).
+///
+/// @callback_signature
+/// @code
+/// void function_name(GLFWwindow* window, int width, int height)
+/// @endcode
+/// For more information about the callback parameters, see the
+/// [function pointer type](@ref GLFWwindowsizefun).
+///
+/// Possible errors include glfw.Error.NotInitialized.
+///
+/// @thread_safety This function must only be called from the main thread.
+///
+/// see also: window_size
+///
+/// @glfw3 Added window handle parameter and return value.
+GLFWAPI GLFWwindowsizefun glfwSetWindowSizeCallback(GLFWwindow* window, GLFWwindowsizefun callback);
+
+/// Sets the close callback for the specified window.
+///
+/// This function sets the close callback of the specified window, which is
+/// called when the user attempts to close the window, for example by clicking
+/// the close widget in the title bar.
+///
+/// The close flag is set before this callback is called, but you can modify it
+/// at any time with @ref glfwSetWindowShouldClose.
+///
+/// The close callback is not triggered by @ref glfwDestroyWindow.
+///
+/// @param[in] window The window whose callback to set.
+/// @param[in] callback The new callback, or null to remove the currently set
+/// callback.
+/// @return The previously set callback, or null if no callback was set or the
+/// library had not been [initialized](@ref intro_init).
+///
+/// @callback_signature
+/// @code
+/// void function_name(GLFWwindow* window)
+/// @endcode
+/// For more information about the callback parameters, see the
+/// [function pointer type](@ref GLFWwindowclosefun).
+///
+/// Possible errors include glfw.Error.NotInitialized.
+///
+/// macos: Selecting Quit from the application menu will trigger the
+/// close callback for all windows.
+///
+/// @thread_safety This function must only be called from the main thread.
+///
+/// see also: window_close
+///
+/// @glfw3 Added window handle parameter and return value.
+GLFWAPI GLFWwindowclosefun glfwSetWindowCloseCallback(GLFWwindow* window, GLFWwindowclosefun callback);
+
+/// Sets the refresh callback for the specified window.
+///
+/// This function sets the refresh callback of the specified window, which is
+/// called when the content area of the window needs to be redrawn, for example
+/// if the window has been exposed after having been covered by another window.
+///
+/// On compositing window systems such as Aero, Compiz, Aqua or Wayland, where
+/// the window contents are saved off-screen, this callback may be called only
+/// very infrequently or never at all.
+///
+/// @param[in] window The window whose callback to set.
+/// @param[in] callback The new callback, or null to remove the currently set
+/// callback.
+/// @return The previously set callback, or null if no callback was set or the
+/// library had not been [initialized](@ref intro_init).
+///
+/// @callback_signature
+/// @code
+/// void function_name(GLFWwindow* window);
+/// @endcode
+/// For more information about the callback parameters, see the
+/// [function pointer type](@ref GLFWwindowrefreshfun).
+///
+/// Possible errors include glfw.Error.NotInitialized.
+///
+/// @thread_safety This function must only be called from the main thread.
+///
+/// see also: window_refresh
+///
+/// @glfw3 Added window handle parameter and return value.
+GLFWAPI GLFWwindowrefreshfun glfwSetWindowRefreshCallback(GLFWwindow* window, GLFWwindowrefreshfun callback);
+
+/// Sets the focus callback for the specified window.
+///
+/// This function sets the focus callback of the specified window, which is
+/// called when the window gains or loses input focus.
+///
+/// After the focus callback is called for a window that lost input focus,
+/// synthetic key and mouse button release events will be generated for all such
+/// that had been pressed. For more information, see @ref glfwSetKeyCallback
+/// and @ref glfwSetMouseButtonCallback.
+///
+/// @param[in] window The window whose callback to set.
+/// @param[in] callback The new callback, or null to remove the currently set
+/// callback.
+/// @return The previously set callback, or null if no callback was set or the
+/// library had not been [initialized](@ref intro_init).
+///
+/// @callback_signature
+/// @code
+/// void function_name(GLFWwindow* window, int focused)
+/// @endcode
+/// For more information about the callback parameters, see the
+/// [function pointer type](@ref GLFWwindowfocusfun).
+///
+/// Possible errors include glfw.Error.NotInitialized.
+///
+/// @thread_safety This function must only be called from the main thread.
+///
+/// see also: window_focus
+///
+GLFWAPI GLFWwindowfocusfun glfwSetWindowFocusCallback(GLFWwindow* window, GLFWwindowfocusfun callback);
+
+/// Sets the iconify callback for the specified window.
+///
+/// This function sets the iconification callback of the specified window, which
+/// is called when the window is iconified or restored.
+///
+/// @param[in] window The window whose callback to set.
+/// @param[in] callback The new callback, or null to remove the currently set
+/// callback.
+/// @return The previously set callback, or null if no callback was set or the
+/// library had not been [initialized](@ref intro_init).
+///
+/// @callback_signature
+/// @code
+/// void function_name(GLFWwindow* window, int iconified)
+/// @endcode
+/// For more information about the callback parameters, see the
+/// [function pointer type](@ref GLFWwindowiconifyfun).
+///
+/// Possible errors include glfw.Error.NotInitialized.
+///
+/// wayland: The wl_shell protocol has no concept of iconification,
+/// this callback will never be called when using this deprecated protocol.
+///
+/// @thread_safety This function must only be called from the main thread.
+///
+/// see also: window_iconify
+///
+GLFWAPI GLFWwindowiconifyfun glfwSetWindowIconifyCallback(GLFWwindow* window, GLFWwindowiconifyfun callback);
+
+/// Sets the maximize callback for the specified window.
+///
+/// This function sets the maximization callback of the specified window, which
+/// is called when the window is maximized or restored.
+///
+/// @param[in] window The window whose callback to set.
+/// @param[in] callback The new callback, or null to remove the currently set
+/// callback.
+/// @return The previously set callback, or null if no callback was set or the
+/// library had not been [initialized](@ref intro_init).
+///
+/// @callback_signature
+/// @code
+/// void function_name(GLFWwindow* window, int maximized)
+/// @endcode
+/// For more information about the callback parameters, see the
+/// [function pointer type](@ref GLFWwindowmaximizefun).
+///
+/// Possible errors include glfw.Error.NotInitialized.
+///
+/// @thread_safety This function must only be called from the main thread.
+///
+/// see also: window_maximize
+///
+GLFWAPI GLFWwindowmaximizefun glfwSetWindowMaximizeCallback(GLFWwindow* window, GLFWwindowmaximizefun callback);
+
+/// Sets the framebuffer resize callback for the specified window.
+///
+/// This function sets the framebuffer resize callback of the specified window,
+/// which is called when the framebuffer of the specified window is resized.
+///
+/// @param[in] window The window whose callback to set.
+/// @param[in] callback The new callback, or null to remove the currently set
+/// callback.
+/// @return The previously set callback, or null if no callback was set or the
+/// library had not been [initialized](@ref intro_init).
+///
+/// @callback_signature
+/// @code
+/// void function_name(GLFWwindow* window, int width, int height)
+/// @endcode
+/// For more information about the callback parameters, see the
+/// [function pointer type](@ref GLFWframebuffersizefun).
+///
+/// Possible errors include glfw.Error.NotInitialized.
+///
+/// @thread_safety This function must only be called from the main thread.
+///
+/// see also: window_fbsize
+///
+GLFWAPI GLFWframebuffersizefun glfwSetFramebufferSizeCallback(GLFWwindow* window, GLFWframebuffersizefun callback);
+
+/// Sets the window content scale callback for the specified window.
+///
+/// This function sets the window content scale callback of the specified window,
+/// which is called when the content scale of the specified window changes.
+///
+/// @param[in] window The window whose callback to set.
+/// @param[in] callback The new callback, or null to remove the currently set
+/// callback.
+/// @return The previously set callback, or null if no callback was set or the
+/// library had not been [initialized](@ref intro_init).
+///
+/// @callback_signature
+/// @code
+/// void function_name(GLFWwindow* window, float xscale, float yscale)
+/// @endcode
+/// For more information about the callback parameters, see the
+/// [function pointer type](@ref GLFWwindowcontentscalefun).
+///
+/// Possible errors include glfw.Error.NotInitialized.
+///
+/// @thread_safety This function must only be called from the main thread.
+///
+/// see also: window_scale, glfw.Window.getContentScale
+///
+GLFWAPI GLFWwindowcontentscalefun glfwSetWindowContentScaleCallback(GLFWwindow* window, GLFWwindowcontentscalefun callback);
+
+/// Processes all pending events.
+///
+/// This function processes only those events that are already in the event
+/// queue and then returns immediately. Processing events will cause the window
+/// and input callbacks associated with those events to be called.
+///
+/// On some platforms, a window move, resize or menu operation will cause event
+/// processing to block. This is due to how event processing is designed on
+/// those platforms. You can use the
+/// [window refresh callback](@ref window_refresh) to redraw the contents of
+/// your window when necessary during such operations.
+///
+/// Do not assume that callbacks you set will _only_ be called in response to
+/// event processing functions like this one. While it is necessary to poll for
+/// events, window systems that require GLFW to register callbacks of its own
+/// can pass events to GLFW in response to many window system function calls.
+/// GLFW will pass those events on to the application callbacks before
+/// returning.
+///
+/// Event processing is not required for joystick input to work.
+///
+/// Possible errors include glfw.Error.NotInitialized and glfw.Error.PlatformError.
+///
+/// @reentrancy This function must not be called from a callback.
+///
+/// @thread_safety This function must only be called from the main thread.
+///
+/// see also: events, glfw.waitEvents, glfw.waitEventsTimeout
+///
+GLFWAPI void glfwPollEvents(void);
+
+/// Waits until events are queued and processes them.
+///
+/// This function puts the calling thread to sleep until at least one event is
+/// available in the event queue. Once one or more events are available,
+/// it behaves exactly like @ref glfwPollEvents, i.e. the events in the queue
+/// are processed and the function then returns immediately. Processing events
+/// will cause the window and input callbacks associated with those events to be
+/// called.
+///
+/// Since not all events are associated with callbacks, this function may return
+/// without a callback having been called even if you are monitoring all
+/// callbacks.
+///
+/// On some platforms, a window move, resize or menu operation will cause event
+/// processing to block. This is due to how event processing is designed on
+/// those platforms. You can use the
+/// [window refresh callback](@ref window_refresh) to redraw the contents of
+/// your window when necessary during such operations.
+///
+/// Do not assume that callbacks you set will _only_ be called in response to
+/// event processing functions like this one. While it is necessary to poll for
+/// events, window systems that require GLFW to register callbacks of its own
+/// can pass events to GLFW in response to many window system function calls.
+/// GLFW will pass those events on to the application callbacks before
+/// returning.
+///
+/// Event processing is not required for joystick input to work.
+///
+/// Possible errors include glfw.Error.NotInitialized and glfw.Error.PlatformError.
+///
+/// @reentrancy This function must not be called from a callback.
+///
+/// @thread_safety This function must only be called from the main thread.
+///
+/// see also: events, glfw.pollEvents, glfw.waitEventsTimeout
+///
+GLFWAPI void glfwWaitEvents(void);
+
+/// Waits with timeout until events are queued and processes them.
+///
+/// This function puts the calling thread to sleep until at least one event is
+/// available in the event queue, or until the specified timeout is reached. If
+/// one or more events are available, it behaves exactly like @ref
+/// glfwPollEvents, i.e. the events in the queue are processed and the function
+/// then returns immediately. Processing events will cause the window and input
+/// callbacks associated with those events to be called.
+///
+/// The timeout value must be a positive finite number.
+///
+/// Since not all events are associated with callbacks, this function may return
+/// without a callback having been called even if you are monitoring all
+/// callbacks.
+///
+/// On some platforms, a window move, resize or menu operation will cause event
+/// processing to block. This is due to how event processing is designed on
+/// those platforms. You can use the
+/// [window refresh callback](@ref window_refresh) to redraw the contents of
+/// your window when necessary during such operations.
+///
+/// Do not assume that callbacks you set will _only_ be called in response to
+/// event processing functions like this one. While it is necessary to poll for
+/// events, window systems that require GLFW to register callbacks of its own
+/// can pass events to GLFW in response to many window system function calls.
+/// GLFW will pass those events on to the application callbacks before
+/// returning.
+///
+/// Event processing is not required for joystick input to work.
+///
+/// @param[in] timeout The maximum amount of time, in seconds, to wait.
+///
+/// Possible errors include glfw.Error.NotInitialized, glfw.Error.InvalidValue and glfw.Error.PlatformError.
+///
+/// @reentrancy This function must not be called from a callback.
+///
+/// @thread_safety This function must only be called from the main thread.
+///
+/// see also: events, glfw.pollEvents, glfw.waitEvents
+///
+GLFWAPI void glfwWaitEventsTimeout(double timeout);
+
+/// Posts an empty event to the event queue.
+///
+/// This function posts an empty event from the current thread to the event
+/// queue, causing @ref glfwWaitEvents or @ref glfwWaitEventsTimeout to return.
+///
+/// Possible errors include glfw.Error.NotInitialized and glfw.Error.PlatformError.
+///
+/// @thread_safety This function may be called from any thread.
+///
+/// see also: events, glfw.waitEvents, glfw.waitEventsTimeout
+///
+GLFWAPI void glfwPostEmptyEvent(void);
+
+/// Returns the value of an input option for the specified window.
+///
+/// This function returns the value of an input option for the specified window.
+/// The mode must be one of @ref GLFW_CURSOR, @ref GLFW_STICKY_KEYS,
+/// @ref GLFW_STICKY_MOUSE_BUTTONS, @ref GLFW_LOCK_KEY_MODS or
+/// @ref GLFW_RAW_MOUSE_MOTION.
+///
+/// @param[in] window The window to query.
+/// @param[in] mode One of `GLFW_CURSOR`, `GLFW_STICKY_KEYS`,
+/// `GLFW_STICKY_MOUSE_BUTTONS`, `GLFW_LOCK_KEY_MODS` or
+/// `GLFW_RAW_MOUSE_MOTION`.
+///
+/// Possible errors include glfw.Error.NotInitialized and glfw.Error.InvalidEnum.
+///
+/// @thread_safety This function must only be called from the main thread.
+///
+/// see also: glfw.setInputMode
+///
+///
+/// @ingroup input
+GLFWAPI int glfwGetInputMode(GLFWwindow* window, int mode);
+
+/// Sets an input option for the specified window.
+///
+/// This function sets an input mode option for the specified window. The mode
+/// must be one of @ref GLFW_CURSOR, @ref GLFW_STICKY_KEYS,
+/// @ref GLFW_STICKY_MOUSE_BUTTONS, @ref GLFW_LOCK_KEY_MODS or
+/// @ref GLFW_RAW_MOUSE_MOTION.
+///
+/// If the mode is `GLFW_CURSOR`, the value must be one of the following cursor
+/// modes:
+/// - `GLFW_CURSOR_NORMAL` makes the cursor visible and behaving normally.
+/// - `GLFW_CURSOR_HIDDEN` makes the cursor invisible when it is over the
+///   content area of the window but does not restrict the cursor from leaving.
+/// - `GLFW_CURSOR_DISABLED` hides and grabs the cursor, providing virtual
+///   and unlimited cursor movement. This is useful for implementing for
+///   example 3D camera controls.
+///
+/// If the mode is `GLFW_STICKY_KEYS`, the value must be either `GLFW_TRUE` to
+/// enable sticky keys, or `GLFW_FALSE` to disable it. If sticky keys are
+/// enabled, a key press will ensure that @ref glfwGetKey returns `GLFW_PRESS`
+/// the next time it is called even if the key had been released before the
+/// call. This is useful when you are only interested in whether keys have been
+/// pressed but not when or in which order.
+///
+/// If the mode is `GLFW_STICKY_MOUSE_BUTTONS`, the value must be either
+/// `GLFW_TRUE` to enable sticky mouse buttons, or `GLFW_FALSE` to disable it.
+/// If sticky mouse buttons are enabled, a mouse button press will ensure that
+/// @ref glfwGetMouseButton returns `GLFW_PRESS` the next time it is called even
+/// if the mouse button had been released before the call. This is useful when
+/// you are only interested in whether mouse buttons have been pressed but not
+/// when or in which order.
+///
+/// If the mode is `GLFW_LOCK_KEY_MODS`, the value must be either `GLFW_TRUE` to
+/// enable lock key modifier bits, or `GLFW_FALSE` to disable them. If enabled,
+/// callbacks that receive modifier bits will also have the @ref
+/// GLFW_MOD_CAPS_LOCK bit set when the event was generated with Caps Lock on,
+/// and the @ref GLFW_MOD_NUM_LOCK bit when Num Lock was on.
+///
+/// If the mode is `GLFW_RAW_MOUSE_MOTION`, the value must be either `GLFW_TRUE`
+/// to enable raw (unscaled and unaccelerated) mouse motion when the cursor is
+/// disabled, or `GLFW_FALSE` to disable it. If raw motion is not supported,
+/// attempting to set this will emit glfw.Error.PlatformError. Call @ref
+/// glfwRawMouseMotionSupported to check for support.
+///
+/// @param[in] window The window whose input mode to set.
+/// @param[in] mode One of `GLFW_CURSOR`, `GLFW_STICKY_KEYS`,
+/// `GLFW_STICKY_MOUSE_BUTTONS`, `GLFW_LOCK_KEY_MODS` or
+/// `GLFW_RAW_MOUSE_MOTION`.
+/// @param[in] value The new value of the specified input mode.
+///
+/// Possible errors include glfw.Error.NotInitialized, glfw.Error.InvalidEnum and glfw.Error.PlatformError.
+///
+/// @thread_safety This function must only be called from the main thread.
+///
+/// see also: glfw.getInputMode
+/// Replaces `glfwEnable` and `glfwDisable`.
+///
+/// @ingroup input
+GLFWAPI void glfwSetInputMode(GLFWwindow* window, int mode, int value);
+
+/// Returns whether raw mouse motion is supported.
+///
+/// This function returns whether raw mouse motion is supported on the current
+/// system. This status does not change after GLFW has been initialized so you
+/// only need to check this once. If you attempt to enable raw motion on
+/// a system that does not support it, glfw.Error.PlatformError will be emitted.
+///
+/// Raw mouse motion is closer to the actual motion of the mouse across
+/// a surface. It is not affected by the scaling and acceleration applied to
+/// the motion of the desktop cursor. That processing is suitable for a cursor
+/// while raw motion is better for controlling for example a 3D camera. Because
+/// of this, raw mouse motion is only provided when the cursor is disabled.
+///
+/// @return `GLFW_TRUE` if raw mouse motion is supported on the current machine,
+/// or `GLFW_FALSE` otherwise.
+///
+/// Possible errors include glfw.Error.NotInitialized.
+///
+/// @thread_safety This function must only be called from the main thread.
+///
+/// see also: raw_mouse_motion, glfw.setInputMode
+///
+///
+/// @ingroup input
+GLFWAPI int glfwRawMouseMotionSupported(void);
+
+/// Returns the layout-specific name of the specified printable key.
+///
+/// This function returns the name of the specified printable key, encoded as
+/// UTF-8. This is typically the character that key would produce without any
+/// modifier keys, intended for displaying key bindings to the user. For dead
+/// keys, it is typically the diacritic it would add to a character.
+///
+/// __Do not use this function__ for [text input](@ref input_char). You will
+/// break text input for many languages even if it happens to work for yours.
+///
+/// If the key is `GLFW_KEY_UNKNOWN`, the scancode is used to identify the key,
+/// otherwise the scancode is ignored. If you specify a non-printable key, or
+/// `GLFW_KEY_UNKNOWN` and a scancode that maps to a non-printable key, this
+/// function returns null but does not emit an error.
+///
+/// This behavior allows you to always pass in the arguments in the
+/// [key callback](@ref input_key) without modification.
+///
+/// The printable keys are:
+/// - `GLFW_KEY_APOSTROPHE`
+/// - `GLFW_KEY_COMMA`
+/// - `GLFW_KEY_MINUS`
+/// - `GLFW_KEY_PERIOD`
+/// - `GLFW_KEY_SLASH`
+/// - `GLFW_KEY_SEMICOLON`
+/// - `GLFW_KEY_EQUAL`
+/// - `GLFW_KEY_LEFT_BRACKET`
+/// - `GLFW_KEY_RIGHT_BRACKET`
+/// - `GLFW_KEY_BACKSLASH`
+/// - `GLFW_KEY_WORLD_1`
+/// - `GLFW_KEY_WORLD_2`
+/// - `GLFW_KEY_0` to `GLFW_KEY_9`
+/// - `GLFW_KEY_A` to `GLFW_KEY_Z`
+/// - `GLFW_KEY_KP_0` to `GLFW_KEY_KP_9`
+/// - `GLFW_KEY_KP_DECIMAL`
+/// - `GLFW_KEY_KP_DIVIDE`
+/// - `GLFW_KEY_KP_MULTIPLY`
+/// - `GLFW_KEY_KP_SUBTRACT`
+/// - `GLFW_KEY_KP_ADD`
+/// - `GLFW_KEY_KP_EQUAL`
+///
+/// Names for printable keys depend on keyboard layout, while names for
+/// non-printable keys are the same across layouts but depend on the application
+/// language and should be localized along with other user interface text.
+///
+/// @param[in] key The key to query, or `GLFW_KEY_UNKNOWN`.
+/// @param[in] scancode The scancode of the key to query.
+/// @return The UTF-8 encoded, layout-specific name of the key, or null.
+///
+/// Possible errors include glfw.Error.NotInitialized and glfw.Error.PlatformError.
+///
+/// The contents of the returned string may change when a keyboard
+/// layout change event is received.
+///
+/// @pointer_lifetime The returned string is allocated and freed by GLFW. You
+/// should not free it yourself. It is valid until the library is terminated.
+///
+/// @thread_safety This function must only be called from the main thread.
+///
+/// see also: input_key_name
+///
+///
+/// @ingroup input
+GLFWAPI const char* glfwGetKeyName(int key, int scancode);
+
+/// Returns the platform-specific scancode of the specified key.
+///
+/// This function returns the platform-specific scancode of the specified key.
+///
+/// If the key is `GLFW_KEY_UNKNOWN` or does not exist on the keyboard this
+/// method will return `-1`.
+///
+/// @param[in] key Any [named key](@ref keys).
+/// @return The platform-specific scancode for the key, or `-1` if an
+/// error occurred.
+///
+/// Possible errors include glfw.Error.NotInitialized, glfw.Error.InvalidEnum and glfw.Error.PlatformError.
+///
+/// @thread_safety This function may be called from any thread.
+///
+/// see also: input_key
+///
+///
+/// @ingroup input
+GLFWAPI int glfwGetKeyScancode(int key);
+
+/// Returns the last reported state of a keyboard key for the specified
+/// window.
+///
+/// This function returns the last state reported for the specified key to the
+/// specified window. The returned state is one of `GLFW_PRESS` or
+/// `GLFW_RELEASE`. The higher-level action `GLFW_REPEAT` is only reported to
+/// the key callback.
+///
+/// If the @ref GLFW_STICKY_KEYS input mode is enabled, this function returns
+/// `GLFW_PRESS` the first time you call it for a key that was pressed, even if
+/// that key has already been released.
+///
+/// The key functions deal with physical keys, with [key tokens](@ref keys)
+/// named after their use on the standard US keyboard layout. If you want to
+/// input text, use the Unicode character callback instead.
+///
+/// The [modifier key bit masks](@ref mods) are not key tokens and cannot be
+/// used with this function.
+///
+/// __Do not use this function__ to implement [text input](@ref input_char).
+///
+/// @param[in] window The desired window.
+/// @param[in] key The desired [keyboard key](@ref keys). `GLFW_KEY_UNKNOWN` is
+/// not a valid key for this function.
+/// @return One of `GLFW_PRESS` or `GLFW_RELEASE`.
+///
+/// Possible errors include glfw.Error.NotInitialized and glfw.Error.InvalidEnum.
+///
+/// @thread_safety This function must only be called from the main thread.
+///
+/// see also: input_key
+///
+/// @glfw3 Added window handle parameter.
+///
+/// @ingroup input
+GLFWAPI int glfwGetKey(GLFWwindow* window, int key);
+
+/// Returns the last reported state of a mouse button for the specified
+/// window.
+///
+/// This function returns the last state reported for the specified mouse button
+/// to the specified window. The returned state is one of `GLFW_PRESS` or
+/// `GLFW_RELEASE`.
+///
+/// If the @ref GLFW_STICKY_MOUSE_BUTTONS input mode is enabled, this function
+/// returns `GLFW_PRESS` the first time you call it for a mouse button that was
+/// pressed, even if that mouse button has already been released.
+///
+/// @param[in] window The desired window.
+/// @param[in] button The desired mouse button.
+/// @return One of `GLFW_PRESS` or `GLFW_RELEASE`.
+///
+/// Possible errors include glfw.Error.NotInitialized and glfw.Error.InvalidEnum.
+///
+/// @thread_safety This function must only be called from the main thread.
+///
+/// see also: input_mouse_button
+///
+/// @glfw3 Added window handle parameter.
+///
+/// @ingroup input
+GLFWAPI int glfwGetMouseButton(GLFWwindow* window, int button);
+
+/// Retrieves the position of the cursor relative to the content area of
+/// the window.
+///
+/// This function returns the position of the cursor, in screen coordinates,
+/// relative to the upper-left corner of the content area of the specified
+/// window.
+///
+/// If the cursor is disabled (with `GLFW_CURSOR_DISABLED`) then the cursor
+/// position is unbounded and limited only by the minimum and maximum values of
+/// a `double`.
+///
+/// The coordinate can be converted to their integer equivalents with the
+/// `floor` function. Casting directly to an integer type works for positive
+/// coordinates, but fails for negative ones.
+///
+/// Any or all of the position arguments may be null. If an error occurs, all
+/// non-null position arguments will be set to zero.
+///
+/// @param[in] window The desired window.
+/// @param[out] xpos Where to store the cursor x-coordinate, relative to the
+/// left edge of the content area, or null.
+/// @param[out] ypos Where to store the cursor y-coordinate, relative to the to
+/// top edge of the content area, or null.
+///
+/// Possible errors include glfw.Error.NotInitialized and glfw.Error.PlatformError.
+///
+/// @thread_safety This function must only be called from the main thread.
+///
+/// see also: cursor_pos, glfw.setCursorPos
+/// Replaces `glfwGetMousePos`.
+///
+/// @ingroup input
+GLFWAPI void glfwGetCursorPos(GLFWwindow* window, double* xpos, double* ypos);
+
+/// Sets the position of the cursor, relative to the content area of the
+/// window.
+///
+/// This function sets the position, in screen coordinates, of the cursor
+/// relative to the upper-left corner of the content area of the specified
+/// window. The window must have input focus. If the window does not have
+/// input focus when this function is called, it fails silently.
+///
+/// __Do not use this function__ to implement things like camera controls. GLFW
+/// already provides the `GLFW_CURSOR_DISABLED` cursor mode that hides the
+/// cursor, transparently re-centers it and provides unconstrained cursor
+/// motion. See @ref glfwSetInputMode for more information.
+///
+/// If the cursor mode is `GLFW_CURSOR_DISABLED` then the cursor position is
+/// unconstrained and limited only by the minimum and maximum values of
+/// a `double`.
+///
+/// @param[in] window The desired window.
+/// @param[in] xpos The desired x-coordinate, relative to the left edge of the
+/// content area.
+/// @param[in] ypos The desired y-coordinate, relative to the top edge of the
+/// content area.
+///
+/// Possible errors include glfw.Error.NotInitialized and glfw.Error.PlatformError.
+///
+/// wayland: This function will only work when the cursor mode is
+/// `GLFW_CURSOR_DISABLED`, otherwise it will do nothing.
+///
+/// @thread_safety This function must only be called from the main thread.
+///
+/// see also: cursor_pos, glfw.getCursorPos
+/// Replaces `glfwSetMousePos`.
+///
+/// @ingroup input
+GLFWAPI void glfwSetCursorPos(GLFWwindow* window, double xpos, double ypos);
+
+/// Creates a custom cursor.
+///
+/// Creates a new custom cursor image that can be set for a window with @ref
+/// glfwSetCursor. The cursor can be destroyed with @ref glfwDestroyCursor.
+/// Any remaining cursors are destroyed by @ref glfwTerminate.
+///
+/// The pixels are 32-bit, little-endian, non-premultiplied RGBA, i.e. eight
+/// bits per channel with the red channel first. They are arranged canonically
+/// as packed sequential rows, starting from the top-left corner.
+///
+/// The cursor hotspot is specified in pixels, relative to the upper-left corner
+/// of the cursor image. Like all other coordinate systems in GLFW, the X-axis
+/// points to the right and the Y-axis points down.
+///
+/// @param[in] image The desired cursor image.
+/// @param[in] xhot The desired x-coordinate, in pixels, of the cursor hotspot.
+/// @param[in] yhot The desired y-coordinate, in pixels, of the cursor hotspot.
+/// @return The handle of the created cursor, or null if an
+/// error occurred.
+///
+/// Possible errors include glfw.Error.NotInitialized and glfw.Error.PlatformError.
+///
+/// @pointer_lifetime The specified image data is copied before this function
+/// returns.
+///
+/// @thread_safety This function must only be called from the main thread.
+///
+/// see also: cursor_object, glfwDestroyCursor, glfwCreateStandardCursor
+///
+///
+/// @ingroup input
+GLFWAPI GLFWcursor* glfwCreateCursor(const GLFWimage* image, int xhot, int yhot);
+
+/// Creates a cursor with a standard shape.
+///
+/// Returns a cursor with a [standard shape](@ref shapes), that can be set for
+/// a window with @ref glfwSetCursor.
+///
+/// @param[in] shape One of the [standard shapes](@ref shapes).
+/// @return A new cursor ready to use or null if an
+/// error occurred.
+///
+/// Possible errors include glfw.Error.NotInitialized, glfw.Error.InvalidEnum and glfw.Error.PlatformError.
+///
+/// @thread_safety This function must only be called from the main thread.
+///
+/// see also: cursor_object, glfwCreateCursor
+///
+///
+/// @ingroup input
+GLFWAPI GLFWcursor* glfwCreateStandardCursor(int shape);
+
+/// Destroys a cursor.
+///
+/// This function destroys a cursor previously created with @ref
+/// glfwCreateCursor. Any remaining cursors will be destroyed by @ref
+/// glfwTerminate.
+///
+/// If the specified cursor is current for any window, that window will be
+/// reverted to the default cursor. This does not affect the cursor mode.
+///
+/// @param[in] cursor The cursor object to destroy.
+///
+/// Possible errors include glfw.Error.NotInitialized and glfw.Error.PlatformError.
+///
+/// @reentrancy This function must not be called from a callback.
+///
+/// @thread_safety This function must only be called from the main thread.
+///
+/// see also: cursor_object, glfwCreateCursor
+///
+///
+/// @ingroup input
+GLFWAPI void glfwDestroyCursor(GLFWcursor* cursor);
+
+/// Sets the cursor for the window.
+///
+/// This function sets the cursor image to be used when the cursor is over the
+/// content area of the specified window. The set cursor will only be visible
+/// when the [cursor mode](@ref cursor_mode) of the window is
+/// `GLFW_CURSOR_NORMAL`.
+///
+/// On some platforms, the set cursor may not be visible unless the window also
+/// has input focus.
+///
+/// @param[in] window The window to set the cursor for.
+/// @param[in] cursor The cursor to set, or null to switch back to the default
+/// arrow cursor.
+///
+/// Possible errors include glfw.Error.NotInitialized and glfw.Error.PlatformError.
+///
+/// @thread_safety This function must only be called from the main thread.
+///
+/// see also: cursor_object
+///
+///
+/// @ingroup input
+GLFWAPI void glfwSetCursor(GLFWwindow* window, GLFWcursor* cursor);
+
+/// Sets the key callback.
+///
+/// This function sets the key callback of the specified window, which is called
+/// when a key is pressed, repeated or released.
+///
+/// The key functions deal with physical keys, with layout independent
+/// [key tokens](@ref keys) named after their values in the standard US keyboard
+/// layout. If you want to input text, use the
+/// [character callback](@ref glfwSetCharCallback) instead.
+///
+/// When a window loses input focus, it will generate synthetic key release
+/// events for all pressed keys. You can tell these events from user-generated
+/// events by the fact that the synthetic ones are generated after the focus
+/// loss event has been processed, i.e. after the
+/// [window focus callback](@ref glfwSetWindowFocusCallback) has been called.
+///
+/// The scancode of a key is specific to that platform or sometimes even to that
+/// machine. Scancodes are intended to allow users to bind keys that don't have
+/// a GLFW key token. Such keys have `key` set to `GLFW_KEY_UNKNOWN`, their
+/// state is not saved and so it cannot be queried with @ref glfwGetKey.
+///
+/// Sometimes GLFW needs to generate synthetic key events, in which case the
+/// scancode may be zero.
+///
+/// @param[in] window The window whose callback to set.
+/// @param[in] callback The new key callback, or null to remove the currently
+/// set callback.
+/// @return The previously set callback, or null if no callback was set or the
+/// library had not been [initialized](@ref intro_init).
+///
+/// @callback_signature
+/// @code
+/// void function_name(GLFWwindow* window, int key, int scancode, int action, int mods)
+/// @endcode
+/// For more information about the callback parameters, see the
+/// [function pointer type](@ref GLFWkeyfun).
+///
+/// Possible errors include glfw.Error.NotInitialized.
+///
+/// @thread_safety This function must only be called from the main thread.
+///
+/// see also: input_key
+///
+/// @glfw3 Added window handle parameter and return value.
+///
+/// @ingroup input
+GLFWAPI GLFWkeyfun glfwSetKeyCallback(GLFWwindow* window, GLFWkeyfun callback);
+
+/// Sets the Unicode character callback.
+///
+/// This function sets the character callback of the specified window, which is
+/// called when a Unicode character is input.
+///
+/// The character callback is intended for Unicode text input. As it deals with
+/// characters, it is keyboard layout dependent, whereas the
+/// [key callback](@ref glfwSetKeyCallback) is not. Characters do not map 1:1
+/// to physical keys, as a key may produce zero, one or more characters. If you
+/// want to know whether a specific physical key was pressed or released, see
+/// the key callback instead.
+///
+/// The character callback behaves as system text input normally does and will
+/// not be called if modifier keys are held down that would prevent normal text
+/// input on that platform, for example a Super (Command) key on macOS or Alt key
+/// on Windows.
+///
+/// @param[in] window The window whose callback to set.
+/// @param[in] callback The new callback, or null to remove the currently set
+/// callback.
+/// @return The previously set callback, or null if no callback was set or the
+/// library had not been [initialized](@ref intro_init).
+///
+/// @callback_signature
+/// @code
+/// void function_name(GLFWwindow* window, unsigned int codepoint)
+/// @endcode
+/// For more information about the callback parameters, see the
+/// [function pointer type](@ref GLFWcharfun).
+///
+/// Possible errors include glfw.Error.NotInitialized.
+///
+/// @thread_safety This function must only be called from the main thread.
+///
+/// see also: input_char
+///
+/// @glfw3 Added window handle parameter and return value.
+///
+/// @ingroup input
+GLFWAPI GLFWcharfun glfwSetCharCallback(GLFWwindow* window, GLFWcharfun callback);
+
+/// Sets the mouse button callback.
+///
+/// This function sets the mouse button callback of the specified window, which
+/// is called when a mouse button is pressed or released.
+///
+/// When a window loses input focus, it will generate synthetic mouse button
+/// release events for all pressed mouse buttons. You can tell these events
+/// from user-generated events by the fact that the synthetic ones are generated
+/// after the focus loss event has been processed, i.e. after the
+/// [window focus callback](@ref glfwSetWindowFocusCallback) has been called.
+///
+/// @param[in] window The window whose callback to set.
+/// @param[in] callback The new callback, or null to remove the currently set
+/// callback.
+/// @return The previously set callback, or null if no callback was set or the
+/// library had not been [initialized](@ref intro_init).
+///
+/// @callback_signature
+/// @code
+/// void function_name(GLFWwindow* window, int button, int action, int mods)
+/// @endcode
+/// For more information about the callback parameters, see the
+/// [function pointer type](@ref GLFWmousebuttonfun).
+///
+/// Possible errors include glfw.Error.NotInitialized.
+///
+/// @thread_safety This function must only be called from the main thread.
+///
+/// see also: input_mouse_button
+///
+/// @glfw3 Added window handle parameter and return value.
+///
+/// @ingroup input
+GLFWAPI GLFWmousebuttonfun glfwSetMouseButtonCallback(GLFWwindow* window, GLFWmousebuttonfun callback);
+
+/// Sets the cursor position callback.
+///
+/// This function sets the cursor position callback of the specified window,
+/// which is called when the cursor is moved. The callback is provided with the
+/// position, in screen coordinates, relative to the upper-left corner of the
+/// content area of the window.
+///
+/// @param[in] window The window whose callback to set.
+/// @param[in] callback The new callback, or null to remove the currently set
+/// callback.
+/// @return The previously set callback, or null if no callback was set or the
+/// library had not been [initialized](@ref intro_init).
+///
+/// @callback_signature
+/// @code
+/// void function_name(GLFWwindow* window, double xpos, double ypos);
+/// @endcode
+/// For more information about the callback parameters, see the
+/// [function pointer type](@ref GLFWcursorposfun).
+///
+/// Possible errors include glfw.Error.NotInitialized.
+///
+/// @thread_safety This function must only be called from the main thread.
+///
+/// see also: cursor_pos
+/// Replaces `glfwSetMousePosCallback`.
+///
+/// @ingroup input
+GLFWAPI GLFWcursorposfun glfwSetCursorPosCallback(GLFWwindow* window, GLFWcursorposfun callback);
+
+/// Sets the cursor enter/leave callback.
+///
+/// This function sets the cursor boundary crossing callback of the specified
+/// window, which is called when the cursor enters or leaves the content area of
+/// the window.
+///
+/// @param[in] window The window whose callback to set.
+/// @param[in] callback The new callback, or null to remove the currently set
+/// callback.
+/// @return The previously set callback, or null if no callback was set or the
+/// library had not been [initialized](@ref intro_init).
+///
+/// @callback_signature
+/// @code
+/// void function_name(GLFWwindow* window, int entered)
+/// @endcode
+/// For more information about the callback parameters, see the
+/// [function pointer type](@ref GLFWcursorenterfun).
+///
+/// Possible errors include glfw.Error.NotInitialized.
+///
+/// @thread_safety This function must only be called from the main thread.
+///
+/// see also: cursor_enter
+///
+///
+/// @ingroup input
+GLFWAPI GLFWcursorenterfun glfwSetCursorEnterCallback(GLFWwindow* window, GLFWcursorenterfun callback);
+
+/// Sets the scroll callback.
+///
+/// This function sets the scroll callback of the specified window, which is
+/// called when a scrolling device is used, such as a mouse wheel or scrolling
+/// area of a touchpad.
+///
+/// The scroll callback receives all scrolling input, like that from a mouse
+/// wheel or a touchpad scrolling area.
+///
+/// @param[in] window The window whose callback to set.
+/// @param[in] callback The new scroll callback, or null to remove the
+/// currently set callback.
+/// @return The previously set callback, or null if no callback was set or the
+/// library had not been [initialized](@ref intro_init).
+///
+/// @callback_signature
+/// @code
+/// void function_name(GLFWwindow* window, double xoffset, double yoffset)
+/// @endcode
+/// For more information about the callback parameters, see the
+/// [function pointer type](@ref GLFWscrollfun).
+///
+/// Possible errors include glfw.Error.NotInitialized.
+///
+/// @thread_safety This function must only be called from the main thread.
+///
+/// see also: scrolling
+/// Replaces `glfwSetMouseWheelCallback`.
+///
+/// @ingroup input
+GLFWAPI GLFWscrollfun glfwSetScrollCallback(GLFWwindow* window, GLFWscrollfun callback);
+
+/// Sets the path drop callback.
+///
+/// This function sets the path drop callback of the specified window, which is
+/// called when one or more dragged paths are dropped on the window.
+///
+/// Because the path array and its strings may have been generated specifically
+/// for that event, they are not guaranteed to be valid after the callback has
+/// returned. If you wish to use them after the callback returns, you need to
+/// make a deep copy.
+///
+/// @param[in] window The window whose callback to set.
+/// @param[in] callback The new file drop callback, or null to remove the
+/// currently set callback.
+/// @return The previously set callback, or null if no callback was set or the
+/// library had not been [initialized](@ref intro_init).
+///
+/// @callback_signature
+/// @code
+/// void function_name(GLFWwindow* window, int path_count, const char* paths[])
+/// @endcode
+/// For more information about the callback parameters, see the
+/// [function pointer type](@ref GLFWdropfun).
+///
+/// Possible errors include glfw.Error.NotInitialized.
+///
+/// wayland: File drop is currently unimplemented.
+///
+/// @thread_safety This function must only be called from the main thread.
+///
+/// see also: path_drop
+///
+///
+/// @ingroup input
+GLFWAPI GLFWdropfun glfwSetDropCallback(GLFWwindow* window, GLFWdropfun callback);
+
+/// Returns whether the specified joystick is present.
+///
+/// This function returns whether the specified joystick is present.
+///
+/// There is no need to call this function before other functions that accept
+/// a joystick ID, as they all check for presence before performing any other
+/// work.
+///
+/// @param[in] jid The [joystick](@ref joysticks) to query.
+/// @return `GLFW_TRUE` if the joystick is present, or `GLFW_FALSE` otherwise.
+///
+/// Possible errors include glfw.Error.NotInitialized, glfw.Error.InvalidEnum and glfw.Error.PlatformError.
+///
+/// @thread_safety This function must only be called from the main thread.
+///
+/// see also: joystick
+/// Replaces `glfwGetJoystickParam`.
+///
+/// @ingroup input
+GLFWAPI int glfwJoystickPresent(int jid);
+
+/// Returns the values of all axes of the specified joystick.
+///
+/// This function returns the values of all axes of the specified joystick.
+/// Each element in the array is a value between -1.0 and 1.0.
+///
+/// If the specified joystick is not present this function will return null
+/// but will not generate an error. This can be used instead of first calling
+/// @ref glfwJoystickPresent.
+///
+/// @param[in] jid The [joystick](@ref joysticks) to query.
+/// @param[out] count Where to store the number of axis values in the returned
+/// array. This is set to zero if the joystick is not present or an error
+/// occurred.
+/// @return An array of axis values, or null if the joystick is not present or
+/// an error occurred.
+///
+/// Possible errors include glfw.Error.NotInitialized, glfw.Error.InvalidEnum and glfw.Error.PlatformError.
+///
+/// @pointer_lifetime The returned array is allocated and freed by GLFW. You
+/// should not free it yourself. It is valid until the specified joystick is
+/// disconnected or the library is terminated.
+///
+/// @thread_safety This function must only be called from the main thread.
+///
+/// see also: joystick_axis
+/// Replaces `glfwGetJoystickPos`.
+///
+/// @ingroup input
+GLFWAPI const float* glfwGetJoystickAxes(int jid, int* count);
+
+/// Returns the state of all buttons of the specified joystick.
+///
+/// This function returns the state of all buttons of the specified joystick.
+/// Each element in the array is either `GLFW_PRESS` or `GLFW_RELEASE`.
+///
+/// For backward compatibility with earlier versions that did not have @ref
+/// glfwGetJoystickHats, the button array also includes all hats, each
+/// represented as four buttons. The hats are in the same order as returned by
+/// __glfwGetJoystickHats__ and are in the order _up_, _right_, _down_ and
+/// _left_. To disable these extra buttons, set the @ref
+/// GLFW_JOYSTICK_HAT_BUTTONS init hint before initialization.
+///
+/// If the specified joystick is not present this function will return null
+/// but will not generate an error. This can be used instead of first calling
+/// @ref glfwJoystickPresent.
+///
+/// @param[in] jid The [joystick](@ref joysticks) to query.
+/// @param[out] count Where to store the number of button states in the returned
+/// array. This is set to zero if the joystick is not present or an error
+/// occurred.
+/// @return An array of button states, or null if the joystick is not present
+/// or an error occurred.
+///
+/// Possible errors include glfw.Error.NotInitialized, glfw.Error.InvalidEnum and glfw.Error.PlatformError.
+///
+/// @pointer_lifetime The returned array is allocated and freed by GLFW. You
+/// should not free it yourself. It is valid until the specified joystick is
+/// disconnected or the library is terminated.
+///
+/// @thread_safety This function must only be called from the main thread.
+///
+/// see also: joystick_button
+///
+/// @glfw3 Changed to return a dynamic array.
+///
+/// @ingroup input
+GLFWAPI const unsigned char* glfwGetJoystickButtons(int jid, int* count);
+
+/// Returns the state of all hats of the specified joystick.
+///
+/// This function returns the state of all hats of the specified joystick.
+/// Each element in the array is one of the following values:
+///
+/// Name                  | Value
+/// ----                  | -----
+/// `GLFW_HAT_CENTERED`   | 0
+/// `GLFW_HAT_UP`         | 1
+/// `GLFW_HAT_RIGHT`      | 2
+/// `GLFW_HAT_DOWN`       | 4
+/// `GLFW_HAT_LEFT`       | 8
+/// `GLFW_HAT_RIGHT_UP`   | `GLFW_HAT_RIGHT` \| `GLFW_HAT_UP`
+/// `GLFW_HAT_RIGHT_DOWN` | `GLFW_HAT_RIGHT` \| `GLFW_HAT_DOWN`
+/// `GLFW_HAT_LEFT_UP`    | `GLFW_HAT_LEFT` \| `GLFW_HAT_UP`
+/// `GLFW_HAT_LEFT_DOWN`  | `GLFW_HAT_LEFT` \| `GLFW_HAT_DOWN`
+///
+/// The diagonal directions are bitwise combinations of the primary (up, right,
+/// down and left) directions and you can test for these individually by ANDing
+/// it with the corresponding direction.
+///
+/// @code
+/// if (hats[2] & GLFW_HAT_RIGHT)
+/// {
+///     // State of hat 2 could be right-up, right or right-down
+/// }
+/// @endcode
+///
+/// If the specified joystick is not present this function will return null
+/// but will not generate an error. This can be used instead of first calling
+/// @ref glfwJoystickPresent.
+///
+/// @param[in] jid The [joystick](@ref joysticks) to query.
+/// @param[out] count Where to store the number of hat states in the returned
+/// array. This is set to zero if the joystick is not present or an error
+/// occurred.
+/// @return An array of hat states, or null if the joystick is not present
+/// or an error occurred.
+///
+/// Possible errors include glfw.Error.NotInitialized, glfw.Error.InvalidEnum and glfw.Error.PlatformError.
+///
+/// @pointer_lifetime The returned array is allocated and freed by GLFW. You
+/// should not free it yourself. It is valid until the specified joystick is
+/// disconnected, this function is called again for that joystick or the library
+/// is terminated.
+///
+/// @thread_safety This function must only be called from the main thread.
+///
+/// see also: joystick_hat
+///
+///
+/// @ingroup input
+GLFWAPI const unsigned char* glfwGetJoystickHats(int jid, int* count);
+
+/// Returns the name of the specified joystick.
+///
+/// This function returns the name, encoded as UTF-8, of the specified joystick.
+/// The returned string is allocated and freed by GLFW. You should not free it
+/// yourself.
+///
+/// If the specified joystick is not present this function will return null
+/// but will not generate an error. This can be used instead of first calling
+/// @ref glfwJoystickPresent.
+///
+/// @param[in] jid The [joystick](@ref joysticks) to query.
+/// @return The UTF-8 encoded name of the joystick, or null if the joystick
+/// is not present or an error occurred.
+///
+/// Possible errors include glfw.Error.NotInitialized, glfw.Error.InvalidEnum and glfw.Error.PlatformError.
+///
+/// @pointer_lifetime The returned string is allocated and freed by GLFW. You
+/// should not free it yourself. It is valid until the specified joystick is
+/// disconnected or the library is terminated.
+///
+/// @thread_safety This function must only be called from the main thread.
+///
+/// see also: joystick_name
+///
+///
+/// @ingroup input
+GLFWAPI const char* glfwGetJoystickName(int jid);
+
+/// Returns the SDL compatible GUID of the specified joystick.
+///
+/// This function returns the SDL compatible GUID, as a UTF-8 encoded
+/// hexadecimal string, of the specified joystick. The returned string is
+/// allocated and freed by GLFW. You should not free it yourself.
+///
+/// The GUID is what connects a joystick to a gamepad mapping. A connected
+/// joystick will always have a GUID even if there is no gamepad mapping
+/// assigned to it.
+///
+/// If the specified joystick is not present this function will return null
+/// but will not generate an error. This can be used instead of first calling
+/// @ref glfwJoystickPresent.
+///
+/// The GUID uses the format introduced in SDL 2.0.5. This GUID tries to
+/// uniquely identify the make and model of a joystick but does not identify
+/// a specific unit, e.g. all wired Xbox 360 controllers will have the same
+/// GUID on that platform. The GUID for a unit may vary between platforms
+/// depending on what hardware information the platform specific APIs provide.
+///
+/// @param[in] jid The [joystick](@ref joysticks) to query.
+/// @return The UTF-8 encoded GUID of the joystick, or null if the joystick
+/// is not present or an error occurred.
+///
+/// Possible errors include glfw.Error.NotInitialized, glfw.Error.InvalidEnum and glfw.Error.PlatformError.
+///
+/// @pointer_lifetime The returned string is allocated and freed by GLFW. You
+/// should not free it yourself. It is valid until the specified joystick is
+/// disconnected or the library is terminated.
+///
+/// @thread_safety This function must only be called from the main thread.
+///
+/// see also: gamepad
+///
+///
+/// @ingroup input
+GLFWAPI const char* glfwGetJoystickGUID(int jid);
+
+/// Sets the user pointer of the specified joystick.
+///
+/// This function sets the user-defined pointer of the specified joystick. The
+/// current value is retained until the joystick is disconnected. The initial
+/// value is null.
+///
+/// This function may be called from the joystick callback, even for a joystick
+/// that is being disconnected.
+///
+/// @param[in] jid The joystick whose pointer to set.
+/// @param[in] pointer The new value.
+///
+/// Possible errors include glfw.Error.NotInitialized.
+///
+/// @thread_safety This function may be called from any thread. Access is not
+/// synchronized.
+///
+/// see also: joystick_userptr, glfwGetJoystickUserPointer
+///
+///
+/// @ingroup input
+GLFWAPI void glfwSetJoystickUserPointer(int jid, void* pointer);
+
+/// Returns the user pointer of the specified joystick.
+///
+/// This function returns the current value of the user-defined pointer of the
+/// specified joystick. The initial value is null.
+///
+/// This function may be called from the joystick callback, even for a joystick
+/// that is being disconnected.
+///
+/// @param[in] jid The joystick whose pointer to return.
+///
+/// Possible errors include glfw.Error.NotInitialized.
+///
+/// @thread_safety This function may be called from any thread. Access is not
+/// synchronized.
+///
+/// see also: joystick_userptr, glfwSetJoystickUserPointer
+///
+///
+/// @ingroup input
+GLFWAPI void* glfwGetJoystickUserPointer(int jid);
+
+/// Returns whether the specified joystick has a gamepad mapping.
+///
+/// This function returns whether the specified joystick is both present and has
+/// a gamepad mapping.
+///
+/// If the specified joystick is present but does not have a gamepad mapping
+/// this function will return `GLFW_FALSE` but will not generate an error. Call
+/// @ref glfwJoystickPresent to check if a joystick is present regardless of
+/// whether it has a mapping.
+///
+/// @param[in] jid The [joystick](@ref joysticks) to query.
+/// @return `GLFW_TRUE` if a joystick is both present and has a gamepad mapping,
+/// or `GLFW_FALSE` otherwise.
+///
+/// Possible errors include glfw.Error.NotInitialized and glfw.Error.InvalidEnum.
+///
+/// @thread_safety This function must only be called from the main thread.
+///
+/// see also: gamepad, glfwGetGamepadState
+///
+///
+/// @ingroup input
+GLFWAPI int glfwJoystickIsGamepad(int jid);
+
+/// Sets the joystick configuration callback.
+///
+/// This function sets the joystick configuration callback, or removes the
+/// currently set callback. This is called when a joystick is connected to or
+/// disconnected from the system.
+///
+/// For joystick connection and disconnection events to be delivered on all
+/// platforms, you need to call one of the [event processing](@ref events)
+/// functions. Joystick disconnection may also be detected and the callback
+/// called by joystick functions. The function will then return whatever it
+/// returns if the joystick is not present.
+///
+/// @param[in] callback The new callback, or null to remove the currently set
+/// callback.
+/// @return The previously set callback, or null if no callback was set or the
+/// library had not been [initialized](@ref intro_init).
+///
+/// @callback_signature
+/// @code
+/// void function_name(int jid, int event)
+/// @endcode
+/// For more information about the callback parameters, see the
+/// [function pointer type](@ref GLFWjoystickfun).
+///
+/// Possible errors include glfw.Error.NotInitialized.
+///
+/// @thread_safety This function must only be called from the main thread.
+///
+/// see also: joystick_event
+///
+///
+/// @ingroup input
+GLFWAPI GLFWjoystickfun glfwSetJoystickCallback(GLFWjoystickfun callback);
+
+/// Adds the specified SDL_GameControllerDB gamepad mappings.
+///
+/// This function parses the specified ASCII encoded string and updates the
+/// internal list with any gamepad mappings it finds. This string may
+/// contain either a single gamepad mapping or many mappings separated by
+/// newlines. The parser supports the full format of the `gamecontrollerdb.txt`
+/// source file including empty lines and comments.
+///
+/// See @ref gamepad_mapping for a description of the format.
+///
+/// If there is already a gamepad mapping for a given GUID in the internal list,
+/// it will be replaced by the one passed to this function. If the library is
+/// terminated and re-initialized the internal list will revert to the built-in
+/// default.
+///
+/// @param[in] string The string containing the gamepad mappings.
+/// @return `GLFW_TRUE` if successful, or `GLFW_FALSE` if an
+/// error occurred.
+///
+/// Possible errors include glfw.Error.NotInitialized and glfw.Error.InvalidValue.
+///
+/// @thread_safety This function must only be called from the main thread.
+///
+/// see also: gamepad, glfwJoystickIsGamepad, glfwGetGamepadName
+///
+///
+/// @ingroup input
+GLFWAPI int glfwUpdateGamepadMappings(const char* string);
+
+/// Returns the human-readable gamepad name for the specified joystick.
+///
+/// This function returns the human-readable name of the gamepad from the
+/// gamepad mapping assigned to the specified joystick.
+///
+/// If the specified joystick is not present or does not have a gamepad mapping
+/// this function will return null but will not generate an error. Call
+/// @ref glfwJoystickPresent to check whether it is present regardless of
+/// whether it has a mapping.
+///
+/// @param[in] jid The [joystick](@ref joysticks) to query.
+/// @return The UTF-8 encoded name of the gamepad, or null if the
+/// joystick is not present, does not have a mapping or an
+/// error occurred.
+///
+/// @pointer_lifetime The returned string is allocated and freed by GLFW. You
+/// should not free it yourself. It is valid until the specified joystick is
+/// disconnected, the gamepad mappings are updated or the library is terminated.
+///
+/// @thread_safety This function must only be called from the main thread.
+///
+/// see also: gamepad, glfwJoystickIsGamepad
+///
+///
+/// @ingroup input
+GLFWAPI const char* glfwGetGamepadName(int jid);
+
+/// Retrieves the state of the specified joystick remapped as a gamepad.
+///
+/// This function retrieves the state of the specified joystick remapped to
+/// an Xbox-like gamepad.
+///
+/// If the specified joystick is not present or does not have a gamepad mapping
+/// this function will return `GLFW_FALSE` but will not generate an error. Call
+/// @ref glfwJoystickPresent to check whether it is present regardless of
+/// whether it has a mapping.
+///
+/// The Guide button may not be available for input as it is often hooked by the
+/// system or the Steam client.
+///
+/// Not all devices have all the buttons or axes provided by @ref
+/// GLFWgamepadstate. Unavailable buttons and axes will always report
+/// `GLFW_RELEASE` and 0.0 respectively.
+///
+/// @param[in] jid The [joystick](@ref joysticks) to query.
+/// @param[out] state The gamepad input state of the joystick.
+/// @return `GLFW_TRUE` if successful, or `GLFW_FALSE` if no joystick is
+/// connected, it has no gamepad mapping or an error
+/// occurred.
+///
+/// Possible errors include glfw.Error.NotInitialized and glfw.Error.InvalidEnum.
+///
+/// @thread_safety This function must only be called from the main thread.
+///
+/// see also: gamepad, glfwUpdateGamepadMappings, glfwJoystickIsGamepad
+///
+///
+/// @ingroup input
+GLFWAPI int glfwGetGamepadState(int jid, GLFWgamepadstate* state);
+
+/// Sets the clipboard to the specified string.
+///
+/// This function sets the system clipboard to the specified, UTF-8 encoded
+/// string.
+///
+/// @param[in] window Deprecated. Any valid window or null.
+/// @param[in] string A UTF-8 encoded string.
+///
+/// Possible errors include glfw.Error.NotInitialized and glfw.Error.PlatformError.
+///
+/// @pointer_lifetime The specified string is copied before this function
+/// returns.
+///
+/// @thread_safety This function must only be called from the main thread.
+///
+/// see also: clipboard, glfwGetClipboardString
+///
+///
+/// @ingroup input
+GLFWAPI void glfwSetClipboardString(GLFWwindow* window, const char* string);
+
+/// Returns the contents of the clipboard as a string.
+///
+/// This function returns the contents of the system clipboard, if it contains
+/// or is convertible to a UTF-8 encoded string. If the clipboard is empty or
+/// if its contents cannot be converted, null is returned and a glfw.Error.FormatUnavailable error is generated.
+///
+/// @param[in] window Deprecated. Any valid window or null.
+/// @return The contents of the clipboard as a UTF-8 encoded string, or null
+/// if an error occurred.
+///
+/// Possible errors include glfw.Error.NotInitialized and glfw.Error.PlatformError.
+///
+/// @pointer_lifetime The returned string is allocated and freed by GLFW. You
+/// should not free it yourself. It is valid until the next call to @ref
+/// glfwGetClipboardString or @ref glfwSetClipboardString, or until the library
+/// is terminated.
+///
+/// @thread_safety This function must only be called from the main thread.
+///
+/// see also: clipboard, glfwSetClipboardString
+///
+///
+/// @ingroup input
+GLFWAPI const char* glfwGetClipboardString(GLFWwindow* window);
+
+/// Returns the GLFW time.
+///
+/// This function returns the current GLFW time, in seconds. Unless the time
+/// has been set using @ref glfwSetTime it measures time elapsed since GLFW was
+/// initialized.
+///
+/// This function and @ref glfwSetTime are helper functions on top of @ref
+/// glfwGetTimerFrequency and @ref glfwGetTimerValue.
+///
+/// The resolution of the timer is system dependent, but is usually on the order
+/// of a few micro- or nanoseconds. It uses the highest-resolution monotonic
+/// time source on each supported platform.
+///
+/// @return The current time, in seconds, or zero if an
+/// error occurred.
+///
+/// Possible errors include glfw.Error.NotInitialized.
+///
+/// @thread_safety This function may be called from any thread. Reading and
+/// writing of the internal base time is not atomic, so it needs to be
+/// externally synchronized with calls to @ref glfwSetTime.
+///
+/// see also: time
+///
+///
+/// @ingroup input
+GLFWAPI double glfwGetTime(void);
+
+/// Sets the GLFW time.
+///
+/// This function sets the current GLFW time, in seconds. The value must be
+/// a positive finite number less than or equal to 18446744073.0, which is
+/// approximately 584.5 years.
+///
+/// This function and @ref glfwGetTime are helper functions on top of @ref
+/// glfwGetTimerFrequency and @ref glfwGetTimerValue.
+///
+/// @param[in] time The new value, in seconds.
+///
+/// Possible errors include glfw.Error.NotInitialized and glfw.Error.InvalidValue.
+///
+/// The upper limit of GLFW time is calculated as
+/// floor((2<sup>64</sup> - 1) / 10<sup>9</sup>) and is due to implementations
+/// storing nanoseconds in 64 bits. The limit may be increased in the future.
+///
+/// @thread_safety This function may be called from any thread. Reading and
+/// writing of the internal base time is not atomic, so it needs to be
+/// externally synchronized with calls to @ref glfwGetTime.
+///
+/// see also: time
+///
+///
+/// @ingroup input
+GLFWAPI void glfwSetTime(double time);
+
+/// Returns the current value of the raw timer.
+///
+/// This function returns the current value of the raw timer, measured in
+/// 1&nbsp;/&nbsp;frequency seconds. To get the frequency, call @ref
+/// glfwGetTimerFrequency.
+///
+/// @return The value of the timer, or zero if an
+/// error occurred.
+///
+/// Possible errors include glfw.Error.NotInitialized.
+///
+/// @thread_safety This function may be called from any thread.
+///
+/// see also: time, glfwGetTimerFrequency
+///
+///
+/// @ingroup input
+GLFWAPI uint64_t glfwGetTimerValue(void);
+
+/// Returns the frequency, in Hz, of the raw timer.
+///
+/// This function returns the frequency, in Hz, of the raw timer.
+///
+/// @return The frequency of the timer, in Hz, or zero if an
+/// error occurred.
+///
+/// Possible errors include glfw.Error.NotInitialized.
+///
+/// @thread_safety This function may be called from any thread.
+///
+/// see also: time, glfwGetTimerValue
+///
+///
+/// @ingroup input
+GLFWAPI uint64_t glfwGetTimerFrequency(void);
+
+/// Makes the context of the specified window current for the calling
+/// thread.
+///
+/// This function makes the OpenGL or OpenGL ES context of the specified window
+/// current on the calling thread. A context must only be made current on
+/// a single thread at a time and each thread can have only a single current
+/// context at a time.
+///
+/// When moving a context between threads, you must make it non-current on the
+/// old thread before making it current on the new one.
+///
+/// By default, making a context non-current implicitly forces a pipeline flush.
+/// On machines that support `GL_KHR_context_flush_control`, you can control
+/// whether a context performs this flush by setting the
+/// [GLFW_CONTEXT_RELEASE_BEHAVIOR](@ref GLFW_CONTEXT_RELEASE_BEHAVIOR_hint)
+/// hint.
+///
+/// The specified window must have an OpenGL or OpenGL ES context. Specifying
+/// a window without a context will generate a @ref GLFW_NO_WINDOW_CONTEXT
+/// error.
+///
+/// @param[in] window The window whose context to make current, or null to
+/// detach the current context.
+///
+/// Possible errors include glfw.Error.NotInitialized, glfw.Error.NoWindowContext and glfw.Error.PlatformError.
+///
+/// @thread_safety This function may be called from any thread.
+///
+/// see also: context_current, glfwGetCurrentContext
+///
+///
+/// @ingroup context
+GLFWAPI void glfwMakeContextCurrent(GLFWwindow* window);
+
+/// Returns the window whose context is current on the calling thread.
+///
+/// This function returns the window whose OpenGL or OpenGL ES context is
+/// current on the calling thread.
+///
+/// @return The window whose context is current, or null if no window's
+/// context is current.
+///
+/// Possible errors include glfw.Error.NotInitialized.
+///
+/// @thread_safety This function may be called from any thread.
+///
+/// see also: context_current, glfwMakeContextCurrent
+///
+///
+/// @ingroup context
+GLFWAPI GLFWwindow* glfwGetCurrentContext(void);
+
+/// Swaps the front and back buffers of the specified window.
+///
+/// This function swaps the front and back buffers of the specified window when
+/// rendering with OpenGL or OpenGL ES. If the swap interval is greater than
+/// zero, the GPU driver waits the specified number of screen updates before
+/// swapping the buffers.
+///
+/// The specified window must have an OpenGL or OpenGL ES context. Specifying
+/// a window without a context will generate a @ref GLFW_NO_WINDOW_CONTEXT
+/// error.
+///
+/// This function does not apply to Vulkan. If you are rendering with Vulkan,
+/// see `vkQueuePresentKHR` instead.
+///
+/// @param[in] window The window whose buffers to swap.
+///
+/// Possible errors include glfw.Error.NotInitialized, glfw.Error.NoWindowContext and glfw.Error.PlatformError.
+///
+/// __EGL:__ The context of the specified window must be current on the
+/// calling thread.
+///
+/// @thread_safety This function may be called from any thread.
+///
+/// see also: buffer_swap, glfwSwapInterval
+///
+/// @glfw3 Added window handle parameter.
+GLFWAPI void glfwSwapBuffers(GLFWwindow* window);
+
+/// Sets the swap interval for the current context.
+///
+/// This function sets the swap interval for the current OpenGL or OpenGL ES
+/// context, i.e. the number of screen updates to wait from the time @ref
+/// glfwSwapBuffers was called before swapping the buffers and returning. This
+/// is sometimes called _vertical synchronization_, _vertical retrace
+/// synchronization_ or just _vsync_.
+///
+/// A context that supports either of the `WGL_EXT_swap_control_tear` and
+/// `GLX_EXT_swap_control_tear` extensions also accepts _negative_ swap
+/// intervals, which allows the driver to swap immediately even if a frame
+/// arrives a little bit late. You can check for these extensions with @ref
+/// glfwExtensionSupported.
+///
+/// A context must be current on the calling thread. Calling this function
+/// without a current context will cause a @ref GLFW_NO_CURRENT_CONTEXT error.
+///
+/// This function does not apply to Vulkan. If you are rendering with Vulkan,
+/// see the present mode of your swapchain instead.
+///
+/// @param[in] interval The minimum number of screen updates to wait for
+/// until the buffers are swapped by @ref glfwSwapBuffers.
+///
+/// Possible errors include glfw.Error.NotInitialized, glfw.Error.NoCurrentContext and glfw.Error.PlatformError.
+///
+/// This function is not called during context creation, leaving the
+/// swap interval set to whatever is the default on that platform. This is done
+/// because some swap interval extensions used by GLFW do not allow the swap
+/// interval to be reset to zero once it has been set to a non-zero value.
+///
+/// Some GPU drivers do not honor the requested swap interval, either
+/// because of a user setting that overrides the application's request or due to
+/// bugs in the driver.
+///
+/// @thread_safety This function may be called from any thread.
+///
+/// see also: buffer_swap, glfwSwapBuffers
+///
+///
+/// @ingroup context
+GLFWAPI void glfwSwapInterval(int interval);
+
+/// Returns whether the specified extension is available.
+///
+/// This function returns whether the specified
+/// [API extension](@ref context_glext) is supported by the current OpenGL or
+/// OpenGL ES context. It searches both for client API extension and context
+/// creation API extensions.
+///
+/// A context must be current on the calling thread. Calling this function
+/// without a current context will cause a @ref GLFW_NO_CURRENT_CONTEXT error.
+///
+/// As this functions retrieves and searches one or more extension strings each
+/// call, it is recommended that you cache its results if it is going to be used
+/// frequently. The extension strings will not change during the lifetime of
+/// a context, so there is no danger in doing this.
+///
+/// This function does not apply to Vulkan. If you are using Vulkan, see @ref
+/// glfw.getRequiredInstanceExtensions, `vkEnumerateInstanceExtensionProperties`
+/// and `vkEnumerateDeviceExtensionProperties` instead.
+///
+/// @param[in] extension The ASCII encoded name of the extension.
+/// @return `GLFW_TRUE` if the extension is available, or `GLFW_FALSE`
+/// otherwise.
+///
+/// Possible errors include glfw.Error.NotInitialized, glfw.Error.NoCurrentContext, glfw.Error.InvalidValue and glfw.Error.PlatformError.
+///
+/// @thread_safety This function may be called from any thread.
+///
+/// see also: context_glext, glfwGetProcAddress
+///
+///
+/// @ingroup context
+GLFWAPI int glfwExtensionSupported(const char* extension);
+
+/// Returns the address of the specified function for the current
+/// context.
+///
+/// This function returns the address of the specified OpenGL or OpenGL ES
+/// [core or extension function](@ref context_glext), if it is supported
+/// by the current context.
+///
+/// A context must be current on the calling thread. Calling this function
+/// without a current context will cause a @ref GLFW_NO_CURRENT_CONTEXT error.
+///
+/// This function does not apply to Vulkan. If you are rendering with Vulkan,
+/// see @ref glfwGetInstanceProcAddress, `vkGetInstanceProcAddr` and
+/// `vkGetDeviceProcAddr` instead.
+///
+/// @param[in] procname The ASCII encoded name of the function.
+/// @return The address of the function, or null if an
+/// error occurred.
+///
+/// Possible errors include glfw.Error.NotInitialized, glfw.Error.NoCurrentContext and glfw.Error.PlatformError.
+///
+/// The address of a given function is not guaranteed to be the same
+/// between contexts.
+///
+/// This function may return a non-null address despite the
+/// associated version or extension not being available. Always check the
+/// context version or extension string first.
+///
+/// @pointer_lifetime The returned function pointer is valid until the context
+/// is destroyed or the library is terminated.
+///
+/// @thread_safety This function may be called from any thread.
+///
+/// see also: context_glext, glfwExtensionSupported
+///
+///
+/// @ingroup context
+GLFWAPI GLFWglproc glfwGetProcAddress(const char* procname);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/// Returns whether the Vulkan loader and an ICD have been found.
+///
+/// This function returns whether the Vulkan loader and any minimally functional ICD have been
+/// found.
+///
+/// The availability of a Vulkan loader and even an ICD does not by itself guarantee that surface
+/// creation or even instance creation is possible. For example, on Fermi systems Nvidia will
+/// install an ICD that provides no actual Vulkan support. Call glfw.getRequiredInstanceExtensions
+/// to check whether the extensions necessary for Vulkan surface creation are available and
+/// glfw.getPhysicalDevicePresentationSupport to check whether a queue family of a physical device
+/// supports image presentation.
+///
+/// @return `GLFW_TRUE` if Vulkan is minimally available, or `GLFW_FALSE` otherwise.
+///
+/// Possible errors include glfw.Error.NotInitialized.
+///
+/// @thread_safety This function may be called from any thread.
+///
+/// see also: vulkan_support
+GLFWAPI int glfwVulkanSupported(void);
+
+/// Returns the Vulkan instance extensions required by GLFW.
+///
+/// This function returns an array of names of Vulkan instance extensions required by GLFW for
+/// creating Vulkan surfaces for GLFW windows. If successful, the list will always contain
+/// `VK_KHR_surface`, so if you don't require any additional extensions you can pass this list
+/// directly to the `VkInstanceCreateInfo` struct.
+///
+/// If Vulkan is not available on the machine, this function returns null and generates a
+/// glfw.Error.APIUnavailable error. Call glfw.vulkanSupported to check whether Vulkan is at least
+/// minimally available.
+///
+/// If Vulkan is available but no set of extensions allowing window surface
+/// creation was found, this function returns null. You may still use Vulkan
+/// for off-screen rendering and compute work.
+///
+/// @param[out] count Where to store the number of extensions in the returned
+/// array. This is set to zero if an error occurred.
+/// @return An array of ASCII encoded extension names, or null if an
+/// error occurred.
+///
+/// Possible errors include glfw.Error.NotInitialized and glfw.Error.APIUnavailable.
+///
+/// Additional extensions may be required by future versions of GLFW. You should check if any
+/// extensions you wish to enable are already in the returned array, as it is an error to specify
+/// an extension more than once in the `VkInstanceCreateInfo` struct.
+///
+/// macos: This function currently supports either the `VK_MVK_macos_surface` extension from
+/// MoltenVK or `VK_EXT_metal_surface` extension.
+///
+/// @pointer_lifetime The returned array is allocated and freed by GLFW. You should not free it
+/// yourself. It is guaranteed to be valid only until the library is terminated.
+///
+/// @thread_safety This function may be called from any thread.
+///
+/// see also: vulkan_ext, glfwCreateWindowSurface
+GLFWAPI const char** glfwGetRequiredInstanceExtensions(uint32_t* count);
+
+/// Returns the address of the specified Vulkan instance function.
+///
+/// This function returns the address of the specified Vulkan core or extension function for the
+/// specified instance. If instance is set to null it can return any function exported from the
+/// Vulkan loader, including at least the following functions:
+///
+/// - `vkEnumerateInstanceExtensionProperties`
+/// - `vkEnumerateInstanceLayerProperties`
+/// - `vkCreateInstance`
+/// - `vkGetInstanceProcAddr`
+///
+/// If Vulkan is not available on the machine, this function returns null and generates a
+/// glfw.Error.APIUnavailable error. Call glfw.vulkanSupported to check whether Vulkan is at least
+/// minimally available.
+///
+/// This function is equivalent to calling `vkGetInstanceProcAddr` with a platform-specific query
+/// of the Vulkan loader as a fallback.
+///
+/// @param[in] instance The Vulkan instance to query, or null to retrieve
+/// functions related to instance creation.
+/// @param[in] procname The ASCII encoded name of the function.
+/// @return The address of the function, or null if an
+/// error occurred.
+///
+/// Possible errors include glfw.Error.NotInitialized and glfw.Error.APIUnavailable.
+///
+/// @pointer_lifetime The returned function pointer is valid until the library is terminated.
+///
+/// @thread_safety This function may be called from any thread.
+///
+/// see also: vulkan_proc
+GLFWAPI GLFWvkproc glfwGetInstanceProcAddress(VkInstance instance, const char* procname);
+
+/// Returns whether the specified queue family can present images.
+///
+/// This function returns whether the specified queue family of the specified physical device
+/// supports presentation to the platform GLFW was built for.
+///
+/// If Vulkan or the required window surface creation instance extensions are not available on the
+/// machine, or if the specified instance was not created with the required extensions, this
+/// function returns `GLFW_FALSE` and generates a glfw.Error.APIUnavailable error. Call
+/// glfw.vulkanSupported to check whether Vulkan is at least minimally available and
+/// glfw.getRequiredInstanceExtensions to check what instance extensions are required.
+///
+/// @param[in] instance The instance that the physical device belongs to.
+/// @param[in] device The physical device that the queue family belongs to.
+/// @param[in] queuefamily The index of the queue family to query.
+/// @return `GLFW_TRUE` if the queue family supports presentation, or
+/// `GLFW_FALSE` otherwise.
+///
+/// Possible errors include glfw.Error.NotInitialized, glfw.Error.APIUnavailable and glfw.Error.PlatformError.
+///
+/// macos: This function currently always returns `GLFW_TRUE`, as the `VK_MVK_macos_surface`
+/// extension does not provide a `vkGetPhysicalDevice*PresentationSupport` type function.
+///
+/// @thread_safety This function may be called from any thread. For synchronization details of
+/// Vulkan objects, see the Vulkan specification.
+///
+/// see also: vulkan_present
+GLFWAPI int glfwGetPhysicalDevicePresentationSupport(VkInstance instance, VkPhysicalDevice device, uint32_t queuefamily);
+
+/// Creates a Vulkan surface for the specified window.
+///
+/// This function creates a Vulkan surface for the specified window.
+///
+/// If the Vulkan loader or at least one minimally functional ICD were not found, this function
+/// returns `VK_ERROR_INITIALIZATION_FAILED` and generates a glfw.Error.APIUnavailable error. Call
+/// glfw.vulkanSupported to check whether Vulkan is at least minimally available.
+///
+/// If the required window surface creation instance extensions are not available or if the
+/// specified instance was not created with these extensions enabled, this function returns `VK_ERROR_EXTENSION_NOT_PRESENT`
+/// and generates a glfw.Error.APIUnavailable error. Call glfw.getRequiredInstanceExtensions to
+/// check what instance extensions are required.
+///
+/// The window surface cannot be shared with another API so the window must have been created with
+/// the client api hint set to `GLFW_NO_API` otherwise it generates a glfw.Error.InvalidValue error
+/// and returns `VK_ERROR_NATIVE_WINDOW_IN_USE_KHR`.
+///
+/// The window surface must be destroyed before the specified Vulkan instance. It is the
+/// responsibility of the caller to destroy the window surface. GLFW does not destroy it for you.
+/// Call `vkDestroySurfaceKHR` to destroy the surface.
+///
+/// @param[in] instance The Vulkan instance to create the surface in.
+/// @param[in] window The window to create the surface for.
+/// @param[in] allocator The allocator to use, or null to use the default
+/// allocator.
+/// @param[out] surface Where to store the handle of the surface. This is set
+/// to `VK_NULL_HANDLE` if an error occurred.
+/// @return `VK_SUCCESS` if successful, or a Vulkan error code if an
+/// error occurred.
+///
+/// Possible errors include glfw.Error.NotInitialized, glfw.Error.APIUnavailable, glfw.Error.PlatformError and glfw.Error.InvalidValue
+///
+/// If an error occurs before the creation call is made, GLFW returns the Vulkan error code most
+/// appropriate for the error. Appropriate use of glfw.vulkanSupported and glfw.getRequiredInstanceExtensions
+/// should eliminate almost all occurrences of these errors.
+///
+/// macos: This function currently only supports the `VK_MVK_macos_surface` extension from MoltenVK.
+///
+/// macos: This function creates and sets a `CAMetalLayer` instance for the window content view,
+/// which is required for MoltenVK to function.
+///
+/// @thread_safety This function may be called from any thread. For synchronization details of
+/// Vulkan objects, see the Vulkan specification.
+///
+/// see also: vulkan_surface, glfw.getRequiredInstanceExtensions
+GLFWAPI VkResult glfwCreateWindowSurface(VkInstance instance, GLFWwindow* window, const VkAllocationCallbacks* allocator, VkSurfaceKHR* surface);